puppet 0.24.9 → 0.25.0

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

@@ -16,21 +16,18 @@ end
 describe Puppet::Network::HTTP::WEBrick, "when turning on listening" do
     before do
         @mock_webrick = stub('webrick', :[] => {})
-        [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)}        
+        [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)}
         WEBrick::HTTPServer.stubs(:new).returns(@mock_webrick)
         @server = Puppet::Network::HTTP::WEBrick.new
-        @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ], :protocols => [ :rest ] }
+        [: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 handler" do
-        Proc.new { @server.listen(@listen_params.delete_if {|k,v| :handlers == k}) }.should raise_error(ArgumentError)
-    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
@@ -38,46 +35,109 @@ describe Puppet::Network::HTTP::WEBrick, "when turning on listening" do
     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)        
+        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" do
+    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
-    
-    it "should instantiate a handler for each protocol+handler pair to configure web server routing" do
-        @listen_params[:protocols].each do |protocol|
-            mock_handler = mock("handler instance for [#{protocol}]")
-            mock_handler_class = mock("handler class for [#{protocol}]")
-            @listen_params[:handlers].each do |handler|
-                @mock_webrick.expects(:mount)
-            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
-        @server.listen(@listen_params)        
     end
 
-    it "should use a WEBrick + REST class to configure WEBrick when REST services are requested" do
-        Puppet::Network::HTTP::WEBrick.expects(:class_for_protocol).with(:rest).at_least_once
-        @server.listen(@listen_params.merge(:protocols => [:rest]))
-    end
-    
-    it "should fail if services from an unknown protocol are requested" do
-        Proc.new { @server.listen(@listen_params.merge(:protocols => [ :foo ]))}.should raise_error
+    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
 
@@ -86,15 +146,15 @@ describe Puppet::Network::HTTP::WEBrick, "when looking up the class to handle a
     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)        
+        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
@@ -105,23 +165,175 @@ describe Puppet::Network::HTTP::WEBrick, "when turning off listening" 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        
+        @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 process name is 'puppetmasterd'" do
+            Puppet.settings.stubs(:value).with(:name).returns "puppetmasterd"
+            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 process name is not 'puppetmasterd'" do
+            Puppet.settings.stubs(:value).with(:name).returns "other"
+            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

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

@@ -4,320 +4,154 @@ require File.dirname(__FILE__) + '/../../../../spec_helper'
 require 'puppet/network/http'
 require 'puppet/network/http/webrick/rest'
 
-describe Puppet::Network::HTTP::WEBrickREST, "when initializing" do
-    before do
-        @mock_webrick = stub('WEBrick server', :mount => true, :[] => {})
-        @mock_model = mock('indirected model')
-        Puppet::Indirector::Indirection.stubs(:model).returns(@mock_model)
-        @params = [ @mock_webrick, :foo ]
+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
 
-    it "should require access to a WEBrick server" do
-        Proc.new { 
-            @params[0] = nil
-            Puppet::Network::HTTP::WEBrickREST.new(*@params)
-        }.should raise_error(ArgumentError)
-    end
-
-    it "should require an indirection name" do
-        Proc.new { Puppet::Network::HTTP::WEBrickREST.new(@params.first) }.should raise_error(ArgumentError)        
-    end
-
-    it "should look up the indirection model from the indirection name" do
-        Puppet::Indirector::Indirection.expects(:model).returns(@mock_model)
-        Puppet::Network::HTTP::WEBrickREST.new(*@params)
-    end
-
-    it "should fail if the indirection is not known" do
-        Puppet::Indirector::Indirection.expects(:model).returns(nil)
-        Proc.new { Puppet::Network::HTTP::WEBrickREST.new(*@params) }.should raise_error(ArgumentError)
-    end
-end
-
-describe Puppet::Network::HTTP::WEBrickREST, "when receiving a request" do
-    before do
-        @mock_request     = stub('webrick http request', :query => {}, :peeraddr => %w{eh boo host ip}, :client_cert => nil)
-        @mock_response    = stub('webrick http response', :status= => true, :body= => true)
-        @mock_model_class = stub('indirected model class')
-        @mock_webrick     = stub('webrick http server', :mount => true, :[] => {})
-        Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@mock_model_class)
-        @handler = Puppet::Network::HTTP::WEBrickREST.new(@mock_webrick, :foo)
-    end
-
-    def setup_find_request
-        @mock_request.stubs(:request_method).returns('GET')
-        @mock_request.stubs(:path).returns('/foo/key')
-        @mock_model_class.stubs(:find)
-    end
-
-    def setup_search_request
-        @mock_request.stubs(:request_method).returns('GET')
-        @mock_request.stubs(:path).returns('/foos')
-        @mock_model_class.stubs(:search).returns([])
-    end
-
-    def setup_destroy_request
-        @mock_request.stubs(:request_method).returns('DELETE')
-        @mock_request.stubs(:path).returns('/foo/key')
-        @mock_model_class.stubs(:destroy)
-    end
-
-    def setup_save_request
-        @mock_request.stubs(:request_method).returns('PUT')
-        @mock_request.stubs(:path).returns('/foo')
-        @mock_request.stubs(:body).returns('This is a fake request body')
-        @mock_model_instance = stub('indirected model instance', :save => true)
-        @mock_model_class.stubs(:from_yaml).returns(@mock_model_instance)
-    end
-
-    def setup_bad_request
-        @mock_request.stubs(:request_method).returns('POST')
-        @mock_request.stubs(:path).returns('/foos')
-    end
-
-    it "should delegate its :service method to its :process method" do
-        @handler.expects(:process).with(@mock_request, @mock_response).returns "stuff"
-        @handler.service(@mock_request, @mock_response).should == "stuff"
-    end
-
-    it "should call the model find method if the request represents a singular HTTP GET" do
-        setup_find_request
-        @mock_model_class.expects(:find).with { |key, args| key == 'key' }
-        @handler.process(@mock_request, @mock_response)
-    end
-
-    it "should call the model search method if the request represents a plural HTTP GET" do
-        setup_search_request
-        @mock_model_class.expects(:search).returns([])
-        @handler.process(@mock_request, @mock_response)
-    end
-
-    it "should call the model destroy method if the request represents an HTTP DELETE" do
-        setup_destroy_request
-        @mock_model_class.expects(:destroy).with { |key, args| key == 'key' }
-        @handler.process(@mock_request, @mock_response)
-    end
-
-    it "should call the model save method if the request represents an HTTP PUT" do
-        setup_save_request
-        @mock_model_instance.expects(:save)
-        @handler.process(@mock_request, @mock_response)
-    end
-
-    it "should fail if the HTTP method isn't supported" do
-        @mock_request.stubs(:request_method).returns('POST')
-        @mock_request.stubs(:path).returns('/foo')
-        @mock_response.expects(:status=).with(404)
-        @handler.process(@mock_request, @mock_response)            
-    end
-
-    it "should fail if delete request's pluralization is wrong" do
-        @mock_request.stubs(:request_method).returns('DELETE')
-        @mock_request.stubs(:path).returns('/foos/key')
-        @mock_response.expects(:status=).with(404)
-        @handler.process(@mock_request, @mock_response)            
-    end
-
-    it "should fail if put request's pluralization is wrong" do 
-        @mock_request.stubs(:request_method).returns('PUT')
-        @mock_request.stubs(:path).returns('/foos/key')
-        @mock_response.expects(:status=).with(404)
-        @handler.process(@mock_request, @mock_response)            
-    end
-
-    it "should fail if the request is for an unknown path" do
-        @mock_request.stubs(:request_method).returns('GET')
-        @mock_request.stubs(:path).returns('/bar/key')
-        @mock_response.expects(:status=).with(404)
-        @handler.process(@mock_request, @mock_response)            
+    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 "and determining the request parameters" do
-        it "should include the HTTP request parameters" do
-            @mock_request.stubs(:query).returns(:foo => :baz, :bar => :xyzzy)
-            result = @handler.params(@mock_request)
-            result[:foo].should == :baz
-            result[:bar].should == :xyzzy
+    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 pass the client's ip address to model find" do
-            @mock_request.stubs(:peeraddr).returns(%w{noidea dunno hostname ipaddress})
-            @handler.params(@mock_request)[:ip].should == "ipaddress"
+        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
 
-        it "should set 'authenticated' to true if a certificate is present" do
-            cert = stub 'cert', :subject => [%w{CN host.domain.com}]
-            @mock_request.stubs(:client_cert).returns cert
-            @handler.params(@mock_request)[:authenticated].should be_true
-        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 set 'authenticated' to false if no certificate is present" do
-            @mock_request.stubs(:client_cert).returns nil
-            @handler.params(@mock_request)[:authenticated].should be_false
-        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 pass the client's certificate name to model method if a certificate is present" do
-            cert = stub 'cert', :subject => [%w{CN host.domain.com}]
-            @mock_request.stubs(:client_cert).returns cert
-            @handler.params(@mock_request)[:node].should == "host.domain.com"
-        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 not pass a node name to model method if no certificate is present" do
-            @mock_request.stubs(:client_cert).returns nil
-            @handler.params(@mock_request).should_not be_include(:node)
-        end
-    end
+            it "should return the request path as the path" do
+                @request.expects(:path).returns "/foo/bar"
+                @handler.path(@request).should == "/foo/bar"
+            end
 
-    describe "when finding a model instance" do |variable|
-        it "should fail to find model if key is not specified" do
-            @mock_request.stubs(:request_method).returns('GET')
-            @mock_request.stubs(:path).returns('/foo')
-            @mock_response.expects(:status=).with(404)
-            @handler.process(@mock_request, @mock_response)            
-        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 use a common method for determining the request parameters" do
-            setup_find_request
-            @handler.stubs(:params).returns(:foo => :baz, :bar => :xyzzy)
-            @mock_model_class.expects(:find).with do |key, args|
-                args[:foo] == :baz and args[:bar] == :xyzzy
+            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
-            @handler.process(@mock_request, @mock_response)
-        end
 
-        it "should generate a 200 response when a model find call succeeds" do
-            setup_find_request
-            @mock_response.expects(:status=).with(200)
-            @handler.process(@mock_request, @mock_response)      
-        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"
 
-        it "should return a serialized object when a model find call succeeds" do
-            setup_find_request
-            @mock_model_instance = stub('model instance')
-            @mock_model_instance.expects(:to_yaml)
-            @mock_model_class.stubs(:find).returns(@mock_model_instance)
-            @handler.process(@mock_request, @mock_response)                  
-        end
+                @handler.set_response(@response, "mybody", 200)
+            end
 
-        it "should serialize a controller exception when an exception is thrown by find" do
-           setup_find_request
-           @mock_model_class.expects(:find).raises(ArgumentError) 
-           @mock_response.expects(:status=).with(404)
-           @handler.process(@mock_request, @mock_response)        
-        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"
 
-    describe "when destroying a model instance" do |variable|
-        it "should fail to destroy model if key is not specified" do
-            @mock_request.stubs(:request_method).returns('DELETE')
-            @mock_request.stubs(:path).returns('/foo')
-            @mock_response.expects(:status=).with(404)
-            @handler.process(@mock_request, @mock_response)            
+                @handler.set_response(@response, "mybody", 400)
+            end
         end
 
-        it "should use a common method for determining the request parameters" do
-            setup_destroy_request
-            @handler.stubs(:params).returns(:foo => :baz, :bar => :xyzzy)
-            @mock_model_class.expects(:destroy).with do |key, args|
-                args[:foo] == :baz and args[:bar] == :xyzzy
+        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
-            @handler.process(@mock_request, @mock_response)
-        end
 
-        it "should generate a 200 response when a model destroy call succeeds" do
-            setup_destroy_request
-            @mock_response.expects(:status=).with(200)
-            @handler.process(@mock_request, @mock_response)      
-        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 return a serialized success result when a model destroy call succeeds" do
-            setup_destroy_request
-            @mock_model_class.stubs(:destroy).returns(true)
-            @mock_response.expects(:body=).with("--- true\n")
-            @handler.process(@mock_request, @mock_response)
-        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 serialize a controller exception when an exception is thrown by destroy" do
-            setup_destroy_request
-            @mock_model_class.expects(:destroy).raises(ArgumentError) 
-            @mock_response.expects(:status=).with(404)
-            @handler.process(@mock_request, @mock_response)                 
-        end       
-    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
 
-    describe "when saving a model instance" do
-        it "should fail to save model if data is not specified" do
-            @mock_request.stubs(:request_method).returns('PUT')
-            @mock_request.stubs(:path).returns('/foo')
-            @mock_request.stubs(:body).returns('')
-            @mock_response.expects(:status=).with(404)
-            @handler.process(@mock_request, @mock_response)            
-        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 use a common method for determining the request parameters" do
-            setup_save_request
-            @handler.stubs(:params).returns(:foo => :baz, :bar => :xyzzy)
-            @mock_model_instance.expects(:save).with do |args|
-                args[:foo] == :baz and args[:bar] == :xyzzy
+            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
-            @handler.process(@mock_request, @mock_response)
-        end
 
-        it "should generate a 200 response when a model save call succeeds" do
-            setup_save_request
-            @mock_response.expects(:status=).with(200)
-            @handler.process(@mock_request, @mock_response)            
-        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 return a serialized object when a model save call succeeds" do
-            setup_save_request
-            @mock_model_instance.stubs(:save).returns(@mock_model_instance)
-            @mock_model_instance.expects(:to_yaml).returns('foo')
-            @handler.process(@mock_request, @mock_response)        
-        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 serialize a controller exception when an exception is thrown by save" do
-            setup_save_request
-            @mock_model_instance.expects(:save).raises(ArgumentError) 
-            @mock_response.expects(:status=).with(404)
-            @handler.process(@mock_request, @mock_response)                         
-        end
-    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
 
-    describe "when searching for model instances" do
-        it "should use a common method for determining the request parameters" do
-            setup_search_request
-            @handler.stubs(:params).returns(:foo => :baz, :bar => :xyzzy)
-            @mock_model_class.expects(:search).with do |args|
-                args[:foo] == :baz and args[:bar] == :xyzzy
+            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
-            @handler.process(@mock_request, @mock_response)
-        end
 
-        it "should generate a 200 response when a model search call succeeds" do
-            setup_search_request
-            @mock_response.expects(:status=).with(200)
-            @handler.process(@mock_request, @mock_response)      
-        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 return a list of serialized objects when a model search call succeeds" do
-            setup_search_request
-            mock_matches = [1..5].collect {|i| mock("model instance #{i}", :to_yaml => "model instance #{i}") }
-            @mock_model_class.stubs(:search).returns(mock_matches)
-            @handler.process(@mock_request, @mock_response)                          
-        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
 
-        it "should serialize a controller exception when an exception is thrown by search" do
-            setup_search_request
-            @mock_model_class.expects(:search).raises(ArgumentError) 
-            @mock_response.expects(:status=).with(404)
-            @handler.process(@mock_request, @mock_response)                
-        end
-    end
+                @handler.expects(:resolve_node).returns(:resolved_node)
 
-    it "should serialize a controller exception if the request fails" do
-        setup_bad_request     
-        @mock_response.expects(:status=).with(404)
-        @handler.process(@mock_request, @mock_response)        
+                @handler.params(@request)[:node].should == :resolved_node
+            end
+        end
     end
 end