puppet 0.24.6 → 0.24.7

data/spec/unit/network/handler/fileserver.rb

@@ -0,0 +1,179 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/network/handler/fileserver'
+
+
+describe Puppet::Network::Handler::FileServer do
+    require 'tmpdir'
+
+    def create_file(filename)
+        File.open(filename, "w") { |f| f.puts filename}
+    end
+
+    def create_nested_file()
+        dirname = File.join(@basedir, "nested_dir")
+        Dir.mkdir(dirname)
+        file = File.join(dirname, "nested_dir_file")
+        create_file(file)
+    end
+
+    before do
+        @basedir = File.join(Dir.tmpdir(), "test_network_handler")
+        Dir.mkdir(@basedir)
+        @file = File.join(@basedir, "aFile")
+        @link = File.join(@basedir, "aLink")
+        create_file(@file)
+        @mount = Puppet::Network::Handler::FileServer::Mount.new("some_path", @basedir)
+    end
+
+    it "should list a single directory" do
+        @mount.list("/", false, false).should == [["/", "directory"]]
+    end
+
+    it "should list a file within a directory when given the file path" do
+        @mount.list("/aFile", false, "false").should == [["/", "file"]]
+    end
+
+    it "should list a file within a directory when given the file path with recursion" do
+        @mount.list("/aFile", true, "false").should == [["/", "file"]]
+    end
+
+    it "should return nil for a non-existent path" do
+        @mount.list("/no_such_file", false, false).should be(nil)
+    end
+
+    it "should list a symbolic link as a file when given the link path" do
+        File.symlink(@file, @link)
+        @mount.list("/aLink", false, false).should == [["/", "file"]]
+    end
+
+    it "should return nil for a dangling symbolic link when given the link path" do
+        File.symlink("/some/where", @link)
+        @mount.list("/aLink", false, false).should be(nil)
+    end
+
+    it "should list directory contents of a flat directory structure when asked to recurse" do
+        list = @mount.list("/", true, false)
+        list.should include(["/aFile", "file"])
+        list.should include(["/", "directory"])
+        list.should have(2).items
+    end
+
+    it "should list the contents of a nested directory" do
+        create_nested_file()
+        list = @mount.list("/", true, false)
+        list.sort.should == [   ["/aFile", "file"], ["/", "directory"] ,
+                                ["/nested_dir", "directory"], ["/nested_dir/nested_dir_file", "file"]].sort
+    end
+
+    it "should list the contents of a directory ignoring files that match" do
+        create_nested_file()
+        list = @mount.list("/", true, "*File")
+        list.sort.should == [   ["/", "directory"] ,
+                                ["/nested_dir", "directory"], ["/nested_dir/nested_dir_file", "file"]].sort
+    end
+
+    it "should list the contents of a directory ignoring directories that match" do
+        create_nested_file()
+        list = @mount.list("/", true, "*nested_dir")
+        list.sort.should == [   ["/aFile", "file"], ["/", "directory"] ].sort
+    end
+
+    it "should list the contents of a directory ignoring all ignore patterns that match" do
+        create_nested_file()
+        list = @mount.list("/", true, ["*File" , "*nested_dir"])
+        list.should == [ ["/", "directory"] ]
+    end
+
+    it "should list the directory when recursing to a depth of zero" do
+        create_nested_file()
+        list = @mount.list("/", 0, false)
+        list.should == [["/", "directory"]]
+    end
+
+    it "should list the base directory and files and nested directory to a depth of one" do
+        create_nested_file()
+        list = @mount.list("/", 1, false)
+        list.sort.should == [ ["/aFile", "file"], ["/nested_dir", "directory"], ["/", "directory"] ].sort
+    end
+
+    it "should list the base directory and files and nested directory to a depth of two" do
+        create_nested_file()
+        list = @mount.list("/", 2, false)
+        list.sort.should == [   ["/aFile", "file"], ["/", "directory"] ,
+                                ["/nested_dir", "directory"], ["/nested_dir/nested_dir_file", "file"]].sort
+    end
+
+    it "should list the base directory and files and nested directory to a depth greater than the directory structure" do
+        create_nested_file()
+        list = @mount.list("/", 42, false)
+        list.sort.should == [   ["/aFile", "file"], ["/", "directory"] ,
+                                ["/nested_dir", "directory"], ["/nested_dir/nested_dir_file", "file"]].sort
+    end
+
+    it "should list a valid symbolic link as a file when recursing base dir" do
+        File.symlink(@file, @link)
+        list = @mount.list("/", true, false)
+        list.sort.should == [ ["/", "directory"], ["/aFile", "file"], ["/aLink", "file"] ].sort
+    end
+
+    it "should not error when a dangling symlink is present" do
+        File.symlink("/some/where", @link)
+        lambda { @mount.list("/", true, false) }.should_not raise_error
+    end
+
+    it "should return the directory contents of valid entries when a dangling symlink is present" do
+        File.symlink("/some/where", @link)
+        list = @mount.list("/", true, false)
+        list.sort.should == [ ["/aFile", "file"], ["/", "directory"] ].sort
+    end
+
+    describe Puppet::Network::Handler::FileServer::PluginMount do
+        PLUGINS = Puppet::Network::Handler::FileServer::PLUGINS
+
+        # create a module plugin hierarchy
+        def create_plugin(mod, plugin)
+            dirname = File.join(@basedir, mod)
+            Dir.mkdir(dirname)
+            plugins = File.join(dirname, PLUGINS)
+            Dir.mkdir(plugins)
+            facter = File.join(plugins, plugin)
+            Dir.mkdir(facter)
+            create_file(File.join(facter,"fact.rb"))
+        end
+
+        before :each do
+            @modules = ["one","two"]
+            Puppet::Module.stubs(:all).returns(@modules.collect{ |p| File.join(@basedir,p)} )
+            @modules.each { |m| create_plugin(m, "facter") }
+
+            @modules.each do |p|
+                File.stubs(:directory?).with(File.join(@basedir,p,PLUGINS)).returns(true)
+            end
+
+            @mount = Puppet::Network::Handler::FileServer::PluginMount.new(PLUGINS)
+            @mount.allow("*")
+        end
+
+        it "should list a file within a directory when given the file path with recursion" do
+            @mount.list("facter/fact.rb", true, "false").should == [["/", "file"], ["/", "file"]]
+         end
+        
+        it "should return a merged view of all plugins for all modules" do
+            list = @mount.list("facter",true,false)
+            list.should == [["/", "directory"], ["/fact.rb", "file"], ["/", "directory"], ["/fact.rb", "file"]]
+        end
+
+        it "should not fail for inexistant plugins type" do
+            lambda { @mount.list("puppet/parser",true,false) }.should_not raise_error
+        end
+
+    end
+
+    after do
+        FileUtils.rm_rf(@basedir)
+    end
+
+end

data/spec/unit/network/http.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+#
+#  Created by Rick Bradley on 2007-10-03.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP do
+    it "should return the webrick HTTP server class when asked for a webrick server" do
+        Puppet::Network::HTTP.server_class_by_type(:webrick).should be(Puppet::Network::HTTP::WEBrick)
+    end
+    
+    describe "when asked for a mongrel server" do
+        if Puppet.features.mongrel?
+            it "should return the mongrel server class" do
+                Puppet::Network::HTTP.server_class_by_type(:mongrel).should be(Puppet::Network::HTTP::Mongrel)
+            end
+        else
+            it "should fail" do
+                lambda { Puppet::Network::HTTP.server_class_by_type(:mongrel) }.should raise_error(ArgumentError)
+            end
+        end
+    end
+    
+    it "should fail to return the mongrel HTTP server class if mongrel is not available " do
+        Puppet.features.expects(:mongrel?).returns(false)
+        Proc.new { Puppet::Network::HTTP.server_class_by_type(:mongrel) }.should raise_error(ArgumentError)
+    end
+    
+    it "should return an error when asked for an unknown server" do
+        Proc.new { Puppet::Network::HTTP.server_class_by_type :foo }.should raise_error(ArgumentError)
+    end
+end

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

@@ -0,0 +1,117 @@
+#!/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'
+
+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'
+
+        Puppet::Network::HTTP::Mongrel.new.should_not be_listening
+    end
+end
+
+describe "Puppet::Network::HTTP::Mongrel", "when turning on listening" do
+    confine "Mongrel is not available" => Puppet.features.mongrel?
+
+    before do
+        require 'puppet/network/http/mongrel'
+
+        @server = Puppet::Network::HTTP::Mongrel.new
+        @mock_mongrel = mock('mongrel')
+        @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 ] }
+    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
+        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)
+    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        
+        @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)
+        @server.unlisten
+        @server.should_not be_listening
+    end
+end

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

@@ -0,0 +1,377 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+require 'puppet/network/http'
+
+describe "Puppet::Network::HTTP::MongrelREST", "when initializing" 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)        
+    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)
+    end
+
+    describe "and determining the request parameters", :shared => true do
+        confine "Mongrel is not available" => Puppet.features.mongrel?
+
+        before do
+            @mock_request.stubs(:params).returns({})
+        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 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 :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 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 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 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
+
+        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 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
+
+        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
+
+    describe "when finding a model instance" do |variable|
+        confine "Mongrel is not available" => Puppet.features.mongrel?
+
+        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
+
+        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
+            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
+
+        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 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
+
+    describe "when destroying a model instance" do |variable|
+        confine "Mongrel is not available" => Puppet.features.mongrel?
+
+        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 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
+            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'
+            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 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 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
+
+    describe "when saving a model instance" do |variable|    
+        confine "Mongrel is not available" => Puppet.features.mongrel?
+
+        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 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
+            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 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 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
+
+    describe "when searching for model instances" do |variable|
+        confine "Mongrel is not available" => Puppet.features.mongrel?
+
+        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
+            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 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 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 serialize a controller exception if the request fails" do
+        setup_bad_request     
+        @mock_response.expects(:start).with(404)
+        @handler.process(@mock_request, @mock_response)        
+    end
+end