puppet 0.24.9 → 0.25.0

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

@@ -8,7 +8,7 @@ require 'puppet/network/http'
 
 describe "Puppet::Network::HTTP::Mongrel", "after initializing" do
     confine "Mongrel is not available" => Puppet.features.mongrel?
-    
+
     it "should not be listening" do
         require 'puppet/network/http/mongrel'
 
@@ -27,87 +27,101 @@ describe "Puppet::Network::HTTP::Mongrel", "when turning on listening" do
         @mock_mongrel.stubs(:run)
         @mock_mongrel.stubs(:register)
         Mongrel::HttpServer.stubs(:new).returns(@mock_mongrel)
-        @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ], :protocols => [ :rest ] }
+
+        @mock_puppet_mongrel = mock('puppet_mongrel')
+        Puppet::Network::HTTPServer::Mongrel.stubs(:new).returns(@mock_puppet_mongrel)
+
+        @listen_params = { :address => "127.0.0.1", :port => 31337, :protocols => [ :rest, :xmlrpc ], :xmlrpc_handlers => [ :status, :fileserver ] }
     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
-    
+
     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 mongrel server to start" do
         @mock_mongrel.expects(:run)
         @server.listen(@listen_params)
     end
-    
+
     it "should tell mongrel to listen on the specified address and port" do
         Mongrel::HttpServer.expects(:new).with("127.0.0.1", 31337).returns(@mock_mongrel)
         @server.listen(@listen_params)
     end
-    
+
     it "should be listening" do
         Mongrel::HttpServer.expects(:new).returns(@mock_mongrel)
         @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|
-            @listen_params[:handlers].each do |handler|
-                @mock_mongrel.expects(:register)
-            end
+    describe "when providing REST services" do
+        it "should instantiate a handler at / for handling REST calls" do
+            Puppet::Network::HTTP::MongrelREST.expects(:new).returns "myhandler"
+            @mock_mongrel.expects(:register).with("/", "myhandler")
+
+            @server.listen(@listen_params)
+        end
+
+        it "should use a Mongrel + REST class to configure Mongrel when REST services are requested" do
+            @server.expects(:class_for_protocol).with(:rest).at_least_once.returns(Puppet::Network::HTTP::MongrelREST)
+            @server.listen(@listen_params)
         end
-        @server.listen(@listen_params)        
-    end
-    
-    it "should use a Mongrel + REST class to configure Mongrel when REST services are requested" do
-        @server.expects(:class_for_protocol).with(:rest).at_least_once.returns(Puppet::Network::HTTP::MongrelREST)
-        @server.listen(@listen_params)
     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(ArgumentError)
+
+    describe "when providing XMLRPC services" do
+        it "should do nothing if no xmlrpc handlers have been provided" do
+            Puppet::Network::HTTPServer::Mongrel.expects(:new).never
+            @server.listen(@listen_params.merge(:xmlrpc_handlers => []))
+        end
+
+        it "should create an instance of the existing Mongrel http server with the right handlers" do
+            Puppet::Network::HTTPServer::Mongrel.expects(:new).with([:status, :master]).returns(@mock_puppet_mongrel)
+            @server.listen(@listen_params.merge(:xmlrpc_handlers => [:status, :master]))
+        end
+
+        it "should register the Mongrel server instance at /RPC2" do
+            @mock_mongrel.expects(:register).with("/RPC2", @mock_puppet_mongrel)
+
+            @server.listen(@listen_params.merge(:xmlrpc_handlers => [:status, :master]))
+        end
     end
 end
 
 describe "Puppet::Network::HTTP::Mongrel", "when turning off listening" do
     confine "Mongrel is not available" => Puppet.features.mongrel?
-    
+
     before do
         @mock_mongrel = mock('mongrel httpserver')
         @mock_mongrel.stubs(:run)
         @mock_mongrel.stubs(:register)
         Mongrel::HttpServer.stubs(:new).returns(@mock_mongrel)
-        @server = Puppet::Network::HTTP::Mongrel.new        
+        @server = Puppet::Network::HTTP::Mongrel.new
         @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 mongrel server to stop" do
         @server.listen(@listen_params)
         @mock_mongrel.expects(:stop)
         @server.unlisten
     end
-    
+
     it "should not be listening" do
         @server.listen(@listen_params)
         @mock_mongrel.stubs(:stop)

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

@@ -1,377 +1,232 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../../spec_helper'
+
 require 'puppet/network/http'
 
-describe "Puppet::Network::HTTP::MongrelREST", "when initializing" do
+describe "Puppet::Network::HTTP::MongrelREST" do
     confine "Mongrel is not available" => Puppet.features.mongrel?
-
     before do
         require 'puppet/network/http/mongrel/rest'
-
-        @mock_mongrel = mock('Mongrel server')
-        @mock_mongrel.stubs(:register)
-        @mock_model = mock('indirected model')
-        Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@mock_model)
-        @params = { :server => @mock_mongrel, :handler => :foo }
     end
 
-    it "should require access to a Mongrel server" do
-        Proc.new { Puppet::Network::HTTP::MongrelREST.new(@params.delete_if {|k,v| :server == k })}.should raise_error(ArgumentError)
-    end
 
-    it "should require an indirection name" do
-        Proc.new { Puppet::Network::HTTP::MongrelREST.new(@params.delete_if {|k,v| :handler == k })}.should raise_error(ArgumentError)        
+    it "should include the Puppet::Network::HTTP::Handler module" do
+        Puppet::Network::HTTP::MongrelREST.ancestors.should be_include(Puppet::Network::HTTP::Handler)
     end
 
-    it "should look up the indirection model from the indirection name" do
-        Puppet::Indirector::Indirection.expects(:model).with(:foo).returns(@mock_model)
-        Puppet::Network::HTTP::MongrelREST.new(@params)
-    end
-
-    it "should fail if the indirection is not known" do
-        Puppet::Indirector::Indirection.expects(:model).with(:foo).returns(nil)
-        Proc.new { Puppet::Network::HTTP::MongrelREST.new(@params) }.should raise_error(ArgumentError)
-    end
-end
-
-describe "Puppet::Network::HTTP::MongrelREST", "when receiving a request" do
-    confine "Mongrel is not available" => Puppet.features.mongrel?
-
-    before do
-        @mock_request = stub('mongrel http request')
-        @mock_head = stub('response head')
-        @mock_body = stub('response body', :write => true)
-        @mock_response = stub('mongrel http response')
-        @mock_response.stubs(:start).yields(@mock_head, @mock_body)
-        @mock_model_class = stub('indirected model class')
-        @mock_mongrel = stub('mongrel http server', :register => true)
-        Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@mock_model_class)
-        @handler = Puppet::Network::HTTP::MongrelREST.new(:server => @mock_mongrel, :handler => :foo)
-    end
-
-    def setup_find_request(params = {})
-        @mock_request.stubs(:params).returns({  Mongrel::Const::REQUEST_METHOD => 'GET', 
-                                                Mongrel::Const::REQUEST_PATH => '/foo/key',
-                                                'QUERY_STRING' => ''}.merge(params))
-        @mock_model_class.stubs(:find)
-    end
-
-    def setup_search_request(params = {})
-        @mock_request.stubs(:params).returns({  Mongrel::Const::REQUEST_METHOD => 'GET', 
-                                                Mongrel::Const::REQUEST_PATH => '/foos',
-                                                'QUERY_STRING' => '' }.merge(params))
-        @mock_model_class.stubs(:search).returns([])        
-    end
-
-    def setup_destroy_request(params = {})
-        @mock_request.stubs(:params).returns({  Mongrel::Const::REQUEST_METHOD => 'DELETE', 
-                                                Mongrel::Const::REQUEST_PATH => '/foo/key',
-                                                'QUERY_STRING' => '' }.merge(params))
-        @mock_model_class.stubs(:destroy)
-    end
-
-    def setup_save_request(params = {})
-        @mock_request.stubs(:params).returns({  Mongrel::Const::REQUEST_METHOD => 'PUT', 
-                                                Mongrel::Const::REQUEST_PATH => '/foo',
-                                                'QUERY_STRING' => '' }.merge(params))
-        @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(:params).returns({ Mongrel::Const::REQUEST_METHOD => 'POST', Mongrel::Const::REQUEST_PATH => '/foos'})        
-    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(:params).returns({ Mongrel::Const::REQUEST_METHOD => 'POST', Mongrel::Const::REQUEST_PATH => '/foo'})
-        @mock_response.expects(:start).with(404)
-        @handler.process(@mock_request, @mock_response)
-    end
-
-    it "should fail if the request's pluralization is wrong" do
-        @mock_request.stubs(:params).returns({ Mongrel::Const::REQUEST_METHOD => 'DELETE', Mongrel::Const::REQUEST_PATH => '/foos/key'})
-        @mock_response.expects(:start).with(404)
-        @handler.process(@mock_request, @mock_response)
-
-        @mock_request.stubs(:params).returns({ Mongrel::Const::REQUEST_METHOD => 'PUT', Mongrel::Const::REQUEST_PATH => '/foos/key'})
-        @mock_response.expects(:start).with(404)
-        @handler.process(@mock_request, @mock_response)
-    end
-
-    it "should fail if the request is for an unknown path" do
-        @mock_request.stubs(:params).returns({  Mongrel::Const::REQUEST_METHOD => 'GET', 
-                                                Mongrel::Const::REQUEST_PATH => '/bar/key',
-                                                'QUERY_STRING' => '' })
-        @mock_response.expects(:start).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::MongrelREST.any_instance.expects(:initialize_for_puppet).with(:server => "my", :handler => "arguments")
+            Puppet::Network::HTTP::MongrelREST.new(:server => "my", :handler => "arguments")
+        end
     end
 
-    describe "and determining the request parameters", :shared => true do
-        confine "Mongrel is not available" => Puppet.features.mongrel?
-
+    describe "when receiving a request" do
         before do
-            @mock_request.stubs(:params).returns({})
-        end
+            @params = {}
+            @request = stub('mongrel http request', :params => @params)
+
+            @head = stub('response head')
+            @body = stub('response body', :write => true)
+            @response = stub('mongrel http response')
+            @response.stubs(:start).yields(@head, @body)
+            @model_class = stub('indirected model class')
+            @mongrel = stub('mongrel http server', :register => true)
+            Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@model_class)
+            @handler = Puppet::Network::HTTP::MongrelREST.new(:server => @mongrel, :handler => :foo)
+        end
+
+        describe "and using the HTTP Handler interface" do
+            it "should return the HTTP_ACCEPT parameter as the accept header" do
+                @params.expects(:[]).with("HTTP_ACCEPT").returns "myaccept"
+                @handler.accept_header(@request).should == "myaccept"
+            end
 
-        it "should include the HTTP request parameters" do
-            @mock_request.expects(:params).returns('QUERY_STRING' => 'foo=baz&bar=xyzzy')
-            result = @handler.params(@mock_request)
-            result["foo"].should == "baz"
-            result["bar"].should == "xyzzy"
-        end
+            it "should return the Content-Type parameter as the Content-Type header" do
+                @params.expects(:[]).with("HTTP_CONTENT_TYPE").returns "mycontent"
+                @handler.content_type_header(@request).should == "mycontent"
+            end
 
-        it "should pass the client's ip address to model find" do
-            @mock_request.stubs(:params).returns("REMOTE_ADDR" => "ipaddress")
-            @handler.params(@mock_request)[:ip].should == "ipaddress"
-        end
+            it "should use the REQUEST_METHOD as the http method" do
+                @params.expects(:[]).with(Mongrel::Const::REQUEST_METHOD).returns "mymethod"
+                @handler.http_method(@request).should == "mymethod"
+            end
 
-        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"
-            @mock_request.stubs(:params).returns("myheader" => "/CN=host.domain.com")
-            @handler.params(@mock_request)
-        end
+            it "should return the request path as the path" do
+                @params.expects(:[]).with(Mongrel::Const::REQUEST_PATH).returns "/foo/bar"
+                @handler.path(@request).should == "/foo/bar"
+            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"
-            @mock_request.stubs(:params).returns("myheader" => "/CN=host.domain.com")
-            @handler.params(@mock_request)[:node].should == "host.domain.com"
-        end
+            it "should return the request body as the body" do
+                @request.expects(:body).returns StringIO.new("mybody")
+                @handler.body(@request).should == "mybody"
+            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"
-            @mock_request.stubs(:params).returns("myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
-            @handler.params(@mock_request)
-        end
+            it "should set the response's content-type header when setting the content type" do
+                @header = mock 'header'
+                @response.expects(:header).returns @header
+                @header.expects(:[]=).with('Content-Type', "mytype")
 
-        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"
-            @mock_request.stubs(:params).returns("myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
-            @handler.params(@mock_request)[:authenticated].should be_true
-        end
+                @handler.set_content_type(@response, "mytype")
+            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"
-            @mock_request.stubs(:params).returns("myheader" => "whatever", "certheader" => "/CN=host.domain.com")
-            @handler.params(@mock_request)[:authenticated].should be_false
-        end
+            it "should set the status and write the body when setting the response for a successful request" do
+                head = mock 'head'
+                body = mock 'body'
+                @response.expects(:start).with(200).yields(head, body)
 
-        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"
-            @mock_request.stubs(:params).returns("myheader" => nil, "certheader" => "SUCCESS")
-            @handler.params(@mock_request)[:authenticated].should be_false
-        end
+                body.expects(:write).with("mybody")
 
-        it "should not pass a node name to model method if no certificate information is present" do
-            Puppet.settings.stubs(:value).returns "eh"
-            Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
-            @mock_request.stubs(:params).returns("myheader" => nil)
-            @handler.params(@mock_request).should_not be_include(:node)
-        end
-    end
+                @handler.set_response(@response, "mybody", 200)
+            end
 
-    describe "when finding a model instance" do |variable|
-        confine "Mongrel is not available" => Puppet.features.mongrel?
+            it "should set the status and reason and write the body when setting the response for a successful request" do
+                head = mock 'head'
+                body = mock 'body'
+                @response.expects(:start).with(400, false, "mybody").yields(head, body)
 
-        it "should fail to find model if key is not specified" do
-            @mock_request.stubs(:params).returns({ Mongrel::Const::REQUEST_METHOD => 'GET', Mongrel::Const::REQUEST_PATH => '/foo'})
-            @mock_response.expects(:start).with(404)
-            @handler.process(@mock_request, @mock_response)
-        end
+                body.expects(:write).with("mybody")
 
-        it "should use a common method for determining the request parameters" do
-            setup_find_request('QUERY_STRING' => 'foo=baz&bar=xyzzy')
-            @handler.expects(:params).returns(:foo => :baz, :bar => :xyzzy)
-            @mock_model_class.expects(:find).with do |key, args|
-                args[:foo] == :baz and args[:bar] == :xyzzy
+                @handler.set_response(@response, "mybody", 400)
             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(:start).with(200)
-            @handler.process(@mock_request, @mock_response)
-        end
+        describe "and determining the request parameters" do
+            before do
+                @request.stubs(:params).returns({})
+            end
 
-        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
+            it "should skip empty parameter values" do
+                @request.expects(:params).returns('QUERY_STRING' => "&=")
+                lambda { @handler.params(@request) }.should_not raise_error
+            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(:start).with(404)
-           @handler.process(@mock_request, @mock_response)        
-        end
-    end
+            it "should include the HTTP request parameters, with the keys as symbols" do
+                @request.expects(:params).returns('QUERY_STRING' => 'foo=baz&bar=xyzzy')
+                result = @handler.params(@request)
+                result[:foo].should == "baz"
+                result[:bar].should == "xyzzy"
+            end
 
-    describe "when destroying a model instance" do |variable|
-        confine "Mongrel is not available" => Puppet.features.mongrel?
+            it "should CGI-decode the HTTP parameters" do
+                encoding = CGI.escape("foo bar")
+                @request.expects(:params).returns('QUERY_STRING' => "foo=#{encoding}")
+                result = @handler.params(@request)
+                result[:foo].should == "foo bar"
+            end
 
-        it "should fail to destroy model if key is not specified" do
-            @mock_request.stubs(:params).returns({ Mongrel::Const::REQUEST_METHOD => 'DELETE', Mongrel::Const::REQUEST_PATH => '/foo'})
-            @mock_response.expects(:start).with(404)
-            @handler.process(@mock_request, @mock_response)
-        end
+            it "should convert the string 'true' to the boolean" do
+                @request.expects(:params).returns('QUERY_STRING' => 'foo=true')
+                result = @handler.params(@request)
+                result[:foo].should be_true
+            end
 
-        it "should use a common method for determining the request parameters" do
-            setup_destroy_request('QUERY_STRING' => 'foo=baz&bar=xyzzy')
-            @handler.expects(:params).returns(:foo => :baz, :bar => :xyzzy)
-            @mock_model_class.expects(:destroy).with do |key, args|
-                args[:foo] == :baz and args[:bar] == :xyzzy
+            it "should convert the string 'false' to the boolean" do
+                @request.expects(:params).returns('QUERY_STRING' => 'foo=false')
+                result = @handler.params(@request)
+                result[:foo].should be_false
             end
-            @handler.process(@mock_request, @mock_response)
-        end
 
-        it "should pass HTTP request parameters to model destroy" do
-            setup_destroy_request('QUERY_STRING' => 'foo=baz&bar=xyzzy')
-            @mock_model_class.expects(:destroy).with do |key, args|
-                key == 'key' and args['foo'] == 'baz' and args['bar'] == 'xyzzy'
+            it "should convert integer arguments to Integers" do
+                @request.expects(:params).returns('QUERY_STRING' => 'foo=15')
+                result = @handler.params(@request)
+                result[:foo].should == 15
             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(:start).with(200)
-            @handler.process(@mock_request, @mock_response)
-        end
+            it "should convert floating point arguments to Floats" do
+                @request.expects(:params).returns('QUERY_STRING' => 'foo=1.5')
+                result = @handler.params(@request)
+                result[:foo].should == 1.5
+            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_body.expects(:write).with("--- true\n")
-            @handler.process(@mock_request, @mock_response)
-        end
+            it "should YAML-load and URI-decode values that are YAML-encoded" do
+                escaping = CGI.escape(YAML.dump(%w{one two}))
+                @request.expects(:params).returns('QUERY_STRING' => "foo=#{escaping}")
+                result = @handler.params(@request)
+                result[:foo].should == %w{one two}
+            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(:start).with(404)
-            @handler.process(@mock_request, @mock_response)                 
-        end
-    end
+            it "should not allow the client to set the node via the query string" do
+                @request.stubs(:params).returns('QUERY_STRING' => "node=foo")
+                @handler.params(@request)[:node].should be_nil
+            end
 
-    describe "when saving a model instance" do |variable|    
-        confine "Mongrel is not available" => Puppet.features.mongrel?
+            it "should not allow the client to set the IP address via the query string" do
+                @request.stubs(:params).returns('QUERY_STRING' => "ip=foo")
+                @handler.params(@request)[:ip].should be_nil
+            end
 
-        it "should fail to save model if data is not specified" do
-            @mock_request.stubs(:params).returns({ Mongrel::Const::REQUEST_METHOD => 'PUT', Mongrel::Const::REQUEST_PATH => '/foo'})
-            @mock_request.stubs(:body).returns('')
-            @mock_response.expects(:start).with(404)
-            @handler.process(@mock_request, @mock_response)
-        end
+            it "should pass the client's ip address to model find" do
+                @request.stubs(:params).returns("REMOTE_ADDR" => "ipaddress")
+                @handler.params(@request)[:ip].should == "ipaddress"
+            end
 
-        it "should use a common method for determining the request parameters" do
-            setup_save_request('QUERY_STRING' => 'foo=baz&bar=xyzzy')
-            @handler.expects(:params).returns(:foo => :baz, :bar => :xyzzy)
-            @mock_model_instance.expects(:save).with do |args|
-                args[:foo] == :baz and args[:bar] == :xyzzy
+            it "should pass the client's provided X-Forwared-For value as the ip" do
+                @request.stubs(:params).returns("HTTP_X_FORWARDED_FOR" => "ipaddress")
+                @handler.params(@request)[:ip].should == "ipaddress"
             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(:start).with(200)
-            @handler.process(@mock_request, @mock_response)
-        end
+            it "should pass the client's provided X-Forwared-For first value as the ip" do
+                @request.stubs(:params).returns("HTTP_X_FORWARDED_FOR" => "ipproxy1,ipproxy2,ipaddress")
+                @handler.params(@request)[:ip].should == "ipaddress"
+            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 provided X-Forwared-For value as the ip instead of the REMOTE_ADDR" do
+                @request.stubs(:params).returns("REMOTE_ADDR" => "remote_addr")
+                @request.stubs(:params).returns("HTTP_X_FORWARDED_FOR" => "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(:start).with(404)
-            @handler.process(@mock_request, @mock_response)                         
-        end
-    end
+            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"
+                @request.stubs(:params).returns("myheader" => "/CN=host.domain.com")
+                @handler.params(@request)
+            end
 
-    describe "when searching for model instances" do |variable|
-        confine "Mongrel is not available" => Puppet.features.mongrel?
+            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"
+                @request.stubs(:params).returns("myheader" => "/CN=host.domain.com")
+                @handler.params(@request)[:node].should == "host.domain.com"
+            end
 
-        it "should use a common method for determining the request parameters" do
-            setup_search_request('QUERY_STRING' => 'foo=baz&bar=xyzzy')
-            @handler.expects(:params).returns(:foo => :baz, :bar => :xyzzy)
-            @mock_model_class.expects(:search).with do |args|
-                args[:foo] == :baz and args[:bar] == :xyzzy
+            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"
+                @request.stubs(:params).returns("myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
+                @handler.params(@request)
             end
-            @handler.process(@mock_request, @mock_response)
-        end
 
-        it "should pass HTTP request parameters to model search" do
-            setup_search_request('QUERY_STRING' => 'foo=baz&bar=xyzzy')
-            @mock_model_class.expects(:search).with do |args|
-                args['foo'] == 'baz' and args['bar'] == 'xyzzy'
-            end.returns([])
-            @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(:start).with(200)
-            @handler.process(@mock_request, @mock_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"
+                @request.stubs(:params).returns("myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
+                @handler.params(@request)[:authenticated].should be_true
+            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 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"
+                @request.stubs(:params).returns("myheader" => "whatever", "certheader" => "/CN=host.domain.com")
+                @handler.params(@request)[:authenticated].should be_false
+            end
 
-        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(:start).with(404)
-            @handler.process(@mock_request, @mock_response)                
-        end
-    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"
+                @request.stubs(:params).returns("myheader" => nil, "certheader" => "SUCCESS")
+                @handler.params(@request)[:authenticated].should be_false
+            end
 
-    it "should serialize a controller exception if the request fails" do
-        setup_bad_request     
-        @mock_response.expects(:start).with(404)
-        @handler.process(@mock_request, @mock_response)        
+            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"
+                @request.stubs(:params).returns("myheader" => nil)
+                @handler.expects(:resolve_node).returns("host.domain.com")
+                @handler.params(@request)[:node].should == "host.domain.com"
+            end
+        end
     end
 end