puppet 0.24.9 → 0.25.0

data/spec/unit/indirector/rest.rb

@@ -3,10 +3,32 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/indirector/rest'
 
+describe "a REST http call", :shared => true do
+    it "should accept a path" do
+        lambda { @search.send(@method, *@arguments) }.should_not raise_error(ArgumentError)
+    end
+
+    it "should require a path" do
+        lambda { @searcher.send(@method) }.should raise_error(ArgumentError)
+    end
+
+    it "should return the results of deserializing the response to the request" do
+        conn = mock 'connection'
+        conn.stubs(:put).returns @response
+        conn.stubs(:delete).returns @response
+        conn.stubs(:get).returns @response
+        Puppet::Network::HttpPool.stubs(:http_instance).returns conn
+
+        @searcher.expects(:deserialize).with(@response).returns "myobject"
+
+        @searcher.send(@method, *@arguments).should == 'myobject'
+    end
+end
+
 describe Puppet::Indirector::REST do
     before do
         Puppet::Indirector::Terminus.stubs(:register_terminus_class)
-        @model = stub('model')
+        @model = stub('model', :supported_formats => %w{}, :convert_from => nil)
         @instance = stub('model instance')
         @indirection = stub('indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model)
         Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
@@ -17,356 +39,343 @@ describe Puppet::Indirector::REST do
             end
         end
 
+        @response = stub('mock response', :body => 'result', :code => "200")
+        @response.stubs(:[]).with('content-type').returns "text/plain"
+
         @searcher = @rest_class.new
+        @searcher.stubs(:model).returns @model
+    end
+
+    it "should include the v1 REST API module" do
+        Puppet::Indirector::REST.ancestors.should be_include(Puppet::Network::HTTP::API::V1)
+    end
+
+    it "should have a method for specifying what setting a subclass should use to retrieve its server" do
+        @rest_class.should respond_to(:use_server_setting)
+    end
+
+    it "should use any specified setting to pick the server" do
+        @rest_class.expects(:server_setting).returns :servset
+        Puppet.settings.expects(:value).with(:servset).returns "myserver"
+        @rest_class.server.should == "myserver"
     end
-    
-    describe "when locating the REST connection" do
-      before do
-        Puppet.settings.stubs(:value).returns("whatever")
-      end
 
-      it "should return the :server setting as the host" do
+    it "should default to :server for the server setting" do
+        @rest_class.expects(:server_setting).returns nil
         Puppet.settings.expects(:value).with(:server).returns "myserver"
-        @searcher.rest_connection_details[:host].should == "myserver"
-      end
-      
-      it "should return the :masterport (as an Integer) as the port" do
-        Puppet.settings.expects(:value).with(:masterport).returns "1234"
-        @searcher.rest_connection_details[:port].should == 1234
-      end
+        @rest_class.server.should == "myserver"
     end
-    
-    describe "when doing a network fetch" do
-      before :each do
-        Net::HTTP.stubs(:start).returns('result')
-        @details = { :host => '127.0.0.1', :port => 34343 }
-        @searcher.stubs(:rest_connection_details).returns(@details)
-      end
-      
-      it "should accept a path" do
-        lambda { @search.network_fetch('foo') }.should_not raise_error(ArgumentError)
-      end
-      
-      it "should require a path" do
-        lambda { @searcher.network_fetch }.should raise_error(ArgumentError)
-      end
-            
-      it "should look up connection details" do
-        @searcher.expects(:rest_connection_details).returns(@details)
-        @searcher.network_fetch('foo')
-      end
-      
-      it "should use the GET http method" do
-        @mock_result = stub('mock result', :body => 'result')
-        @mock_connection = mock('mock http connection', :get => @mock_result)
-        @searcher.stubs(:network).yields(@mock_connection)
-        @searcher.network_fetch('foo')
-      end
-      
-      it "should use the appropriate remote server" do
-        Net::HTTP.expects(:start).with {|host, port| host == @details[:host] }
-        @searcher.network_fetch('foo')
-      end
-      
-      it "should use the appropriate remote port" do
-        Net::HTTP.expects(:start).with {|host, port| port == @details[:port] }
-        @searcher.network_fetch('foo')
-      end
-      
-      it "should use the provided path" do
-        @mock_result = stub('mock result', :body => 'result')
-        @mock_connection = stub('mock http connection')
-        @mock_connection.expects(:get).with('/foo').returns(@mock_result)
-        @searcher.stubs(:network).yields(@mock_connection)
-        @searcher.network_fetch('foo')
-      end
-                
-      it "should return the results of the GET request" do
-        @searcher.network_fetch('foo').should == 'result'        
-      end
+
+    it "should have a method for specifying what setting a subclass should use to retrieve its port" do
+        @rest_class.should respond_to(:use_port_setting)
     end
 
-    describe "when doing a network delete" do
-      before :each do
-        Net::HTTP.stubs(:start).returns('result')
-        @details = { :host => '127.0.0.1', :port => 34343 }
-        @searcher.stubs(:rest_connection_details).returns(@details)
-      end
-      
-      it "should accept a path" do
-        lambda { @search.network_delete('foo') }.should_not raise_error(ArgumentError)
-      end
-      
-      it "should require a path" do
-        lambda { @searcher.network_delete }.should raise_error(ArgumentError)
-      end
-            
-      it "should look up connection details" do
-        @searcher.expects(:rest_connection_details).returns(@details)
-        @searcher.network_delete('foo')
-      end
-      
-      it "should use the DELETE http method" do
-        @mock_result = stub('mock result', :body => 'result')
-        @mock_connection = mock('mock http connection', :delete => @mock_result)
-        @searcher.stubs(:network).yields(@mock_connection)
-        @searcher.network_delete('foo')
-      end
-      
-      it "should use the appropriate remote server" do
-        Net::HTTP.expects(:start).with {|host, port| host == @details[:host] }
-        @searcher.network_delete('foo')
-      end
-      
-      it "should use the appropriate remote port" do
-        Net::HTTP.expects(:start).with {|host, port| port == @details[:port] }
-        @searcher.network_delete('foo')
-      end
-      
-      it "should use the provided path" do
-        @mock_result = stub('mock result', :body => 'result')
-        @mock_connection = stub('mock http connection')
-        @mock_connection.expects(:delete).with('/foo').returns(@mock_result)
-        @searcher.stubs(:network).yields(@mock_connection)
-        @searcher.network_delete('foo')
-      end
-            
-      it "should return the results of the DELETE request" do
-        @searcher.network_delete('foo').should == 'result'        
-      end    
+    it "should use any specified setting to pick the port" do
+        @rest_class.expects(:port_setting).returns :servset
+        Puppet.settings.expects(:value).with(:servset).returns "321"
+        @rest_class.port.should == 321
     end
-    
-    describe "when doing a network put" do
-      before :each do
-        Net::HTTP.stubs(:start).returns('result')
-        @details = { :host => '127.0.0.1', :port => 34343 }
-        @data = { :foo => 'bar' }
-        @searcher.stubs(:rest_connection_details).returns(@details)
-      end
-      
-      it "should accept a path and data" do
-        lambda { @search.network_put('foo', @data) }.should_not raise_error(ArgumentError)
-      end
-      
-      it "should require a path and data" do
-        lambda { @searcher.network_put('foo') }.should raise_error(ArgumentError)
-      end
-      
-      it "should look up connection details" do
-        @searcher.expects(:rest_connection_details).returns(@details)
-        @searcher.network_put('foo', @data)
-      end
-      
-      it "should use the appropriate remote server" do
-        Net::HTTP.expects(:start).with {|host, port| host == @details[:host] }
-        @searcher.network_put('foo', @data)
-      end
-      
-      it "should use the appropriate remote port" do
-        Net::HTTP.expects(:start).with {|host, port| port == @details[:port] }
-        @searcher.network_put('foo', @data)
-      end
-      
-      it "should use the PUT http method" do
-        @mock_result = stub('mock result', :body => 'result')
-        @mock_connection = mock('mock http connection', :put => @mock_result)
-        @searcher.stubs(:network).yields(@mock_connection)
-        @searcher.network_put('foo', @data)
-      end
-      
-      it "should use the provided path" do
-        @mock_result = stub('mock result', :body => 'result')
-        @mock_connection = stub('mock http connection')
-        @mock_connection.expects(:put).with {|path, data| path == '/foo' }.returns(@mock_result)
-        @searcher.stubs(:network).yields(@mock_connection)
-        @searcher.network_put('foo', @data)        
-      end
-      
-      it "should use the provided data" do
-        @mock_result = stub('mock result', :body => 'result')
-        @mock_connection = stub('mock http connection')
-        @mock_connection.expects(:put).with {|path, data| data == @data }.returns(@mock_result)
-        @searcher.stubs(:network).yields(@mock_connection)
-        @searcher.network_put('foo', @data)                
-      end
-      
-      it "should return the results of the PUT request" do
-        @searcher.network_put('foo', @data).should == 'result'        
-      end    
+
+    it "should default to :port for the port setting" do
+        @rest_class.expects(:port_setting).returns nil
+        Puppet.settings.expects(:value).with(:masterport).returns "543"
+        @rest_class.port.should == 543
+    end
+
+    describe "when deserializing responses" do
+        it "should return nil if the response code is 404" do
+            response = mock 'response'
+            response.expects(:code).returns "404"
+
+            @searcher.deserialize(response).should be_nil
+        end
+
+        it "should fail if the response code is not in the 200s" do
+            @model.expects(:convert_from).never
+
+            response = mock 'response'
+            response.stubs(:code).returns "300"
+            response.stubs(:message).returns "There was a problem"
+
+            lambda { @searcher.deserialize(response) }.should raise_error(Net::HTTPError)
+        end
+
+        it "should return the results of converting from the format specified by the content-type header if the response code is in the 200s" do
+            @model.expects(:convert_from).with("myformat", "mydata").returns "myobject"
+
+            response = mock 'response'
+            response.stubs(:[]).with("content-type").returns "myformat"
+            response.stubs(:body).returns "mydata"
+            response.stubs(:code).returns "200"
+
+            @searcher.deserialize(response).should == "myobject"
+        end
+
+        it "should convert and return multiple instances if the return code is in the 200s and 'multiple' is specified" do
+            @model.expects(:convert_from_multiple).with("myformat", "mydata").returns "myobjects"
+
+            response = mock 'response'
+            response.stubs(:[]).with("content-type").returns "myformat"
+            response.stubs(:body).returns "mydata"
+            response.stubs(:code).returns "200"
+
+            @searcher.deserialize(response, true).should == "myobjects"
+        end
+
+        it "should strip the content-type header to keep only the mime-type" do
+            @model.expects(:convert_from).with("text/plain", "mydata").returns "myobject"
+
+            response = mock 'response'
+            response.stubs(:[]).with("content-type").returns "text/plain; charset=utf-8"
+            response.stubs(:body).returns "mydata"
+            response.stubs(:code).returns "200"
+
+            @searcher.deserialize(response)
+        end
+    end
+
+    describe "when creating an HTTP client" do
+        before do
+            Puppet.settings.stubs(:value).returns("rest_testing")
+        end
+
+        it "should use the class's server and port if the indirection request provides neither" do
+            @request = stub 'request', :key => "foo", :server => nil, :port => nil
+            @searcher.class.expects(:port).returns 321
+            @searcher.class.expects(:server).returns "myserver"
+            Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
+            @searcher.network(@request).should == "myconn"
+        end
+
+        it "should use the server from the indirection request if one is present" do
+            @request = stub 'request', :key => "foo", :server => "myserver", :port => nil
+            @searcher.class.stubs(:port).returns 321
+            Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
+            @searcher.network(@request).should == "myconn"
+        end
+
+        it "should use the port from the indirection request if one is present" do
+            @request = stub 'request', :key => "foo", :server => nil, :port => 321
+            @searcher.class.stubs(:server).returns "myserver"
+            Puppet::Network::HttpPool.expects(:http_instance).with("myserver", 321).returns "myconn"
+            @searcher.network(@request).should == "myconn"
+        end
     end
 
     describe "when doing a find" do
-      before :each do
-        @result = { :foo => 'bar'}.to_yaml
-        @searcher.stubs(:network_fetch).returns(@result)  # neuter the network connection
-        @model.stubs(:from_yaml).returns(@instance)
-
-        @request = stub 'request', :key => 'foo'
-      end
-      
-      it "should look up the model instance over the network" do
-        @searcher.expects(:network_fetch).returns(@result)
-        @searcher.find(@request)
-      end
-      
-      it "should look up the model instance using the named indirection" do
-        @searcher.expects(:network_fetch).with {|path| path =~ %r{^#{@indirection.name.to_s}/} }.returns(@result)
-        @searcher.find(@request)
-      end
-      
-      it "should look up the model instance using the provided key" do
-        @searcher.expects(:network_fetch).with {|path| path =~ %r{/foo$} }.returns(@result)
-        @searcher.find(@request)
-      end
-      
-      it "should deserialize result data to a Model instance" do
-        @model.expects(:from_yaml)
-        @searcher.find(@request)
-      end
-      
-      it "should return the deserialized Model instance" do
-        @searcher.find(@request).should == @instance     
-      end
-      
-      it "should return nil when deserialized model instance is nil" do
-        @model.stubs(:from_yaml).returns(nil)
-        @searcher.find(@request).should be_nil
-      end
-      
-      it "should generate an error when result data deserializes improperly" do
-        @model.stubs(:from_yaml).raises(ArgumentError)
-        lambda { @searcher.find(@request) }.should raise_error(ArgumentError)
-      end
-      
-      it "should generate an error when result data specifies an error" do
-        @searcher.stubs(:network_fetch).returns(RuntimeError.new("bogus").to_yaml)
-        lambda { @searcher.find(@request) }.should raise_error(RuntimeError)        
-      end      
+        before :each do
+            @connection = stub('mock http connection', :get => @response)
+            @searcher.stubs(:network).returns(@connection)    # neuter the network connection
+
+            # Use a key with spaces, so we can test escaping
+            @request = Puppet::Indirector::Request.new(:foo, :find, "foo bar")
+        end
+
+        it "should call the GET http method on a network connection" do
+            @searcher.expects(:network).returns @connection
+            @connection.expects(:get).returns @response
+            @searcher.find(@request)
+        end
+
+        it "should deserialize and return the http response" do
+            @connection.expects(:get).returns @response
+            @searcher.expects(:deserialize).with(@response).returns "myobject"
+
+            @searcher.find(@request).should == 'myobject'
+        end
+
+        it "should use the URI generated by the Handler module" do
+            @searcher.expects(:indirection2uri).with(@request).returns "/my/uri"
+            @connection.expects(:get).with { |path, args| path == "/my/uri" }.returns(@response)
+            @searcher.find(@request)
+        end
+
+        it "should provide an Accept header containing the list of supported formats joined with commas" do
+            @connection.expects(:get).with { |path, args| args["Accept"] == "supported, formats" }.returns(@response)
+
+            @searcher.model.expects(:supported_formats).returns %w{supported formats}
+            @searcher.find(@request)
+        end
+
+        it "should deserialize and return the network response" do
+            @searcher.expects(:deserialize).with(@response).returns @instance
+            @searcher.find(@request).should equal(@instance)
+        end
+
+        it "should generate an error when result data deserializes fails" do
+            @searcher.expects(:deserialize).raises(ArgumentError)
+            lambda { @searcher.find(@request) }.should raise_error(ArgumentError)
+        end
     end
 
     describe "when doing a search" do
-      before :each do
-        @result = [1, 2].to_yaml
-        @searcher.stubs(:network_fetch).returns(@result)
-        @model.stubs(:from_yaml).returns(@instance)
-
-        @request = stub 'request', :key => 'foo'
-      end
-      
-      it "should look up the model data over the network" do
-        @searcher.expects(:network_fetch).returns(@result)
-        @searcher.search(@request)
-      end
-      
-      it "should look up the model instance using the named indirection" do
-        @searcher.expects(:network_fetch).with {|path| path =~ %r{^#{@indirection.name.to_s}s/} }.returns(@result)
-        @searcher.search(@request)
-      end
-      
-      it "should look up the model instance using the provided key" do
-        @searcher.expects(:network_fetch).with {|path| path =~ %r{/foo$} }.returns(@result)
-        @searcher.search(@request)
-      end
-      
-      it "should deserialize result data into a list of Model instances" do
-        @model.expects(:from_yaml).at_least(2)
-        @searcher.search(@request)
-      end
-      
-      it "should generate an error when result data deserializes improperly" do
-        @model.stubs(:from_yaml).raises(ArgumentError)
-        lambda { @searcher.search(@request) }.should raise_error(ArgumentError)        
-      end
-      
-      it "should generate an error when result data specifies an error" do
-        @searcher.stubs(:network_fetch).returns(RuntimeError.new("bogus").to_yaml)
-        lambda { @searcher.search(@request) }.should raise_error(RuntimeError)        
-      end     
-    end    
-    
+        before :each do
+            @connection = stub('mock http connection', :get => @response)
+            @searcher.stubs(:network).returns(@connection)    # neuter the network connection
+
+            @model.stubs(:convert_from_multiple)
+
+            @request = Puppet::Indirector::Request.new(:foo, :search, "foo bar")
+        end
+
+        it "should call the GET http method on a network connection" do
+            @searcher.expects(:network).returns @connection
+            @connection.expects(:get).returns @response
+            @searcher.search(@request)
+        end
+
+        it "should deserialize as multiple instances and return the http response" do
+            @connection.expects(:get).returns @response
+            @searcher.expects(:deserialize).with(@response, true).returns "myobject"
+
+            @searcher.search(@request).should == 'myobject'
+        end
+
+        it "should use the URI generated by the Handler module" do
+            @searcher.expects(:indirection2uri).with(@request).returns "/mys/uri"
+            @connection.expects(:get).with { |path, args| path == "/mys/uri" }.returns(@response)
+            @searcher.search(@request)
+        end
+
+        it "should provide an Accept header containing the list of supported formats joined with commas" do
+            @connection.expects(:get).with { |path, args| args["Accept"] == "supported, formats" }.returns(@response)
+
+            @searcher.model.expects(:supported_formats).returns %w{supported formats}
+            @searcher.search(@request)
+        end
+
+        it "should return an empty array if serialization returns nil" do
+            @model.stubs(:convert_from_multiple).returns nil
+
+            @searcher.search(@request).should == []
+        end
+
+        it "should generate an error when result data deserializes fails" do
+            @searcher.expects(:deserialize).raises(ArgumentError)
+            lambda { @searcher.search(@request) }.should raise_error(ArgumentError)
+        end
+    end
+
     describe "when doing a destroy" do
-      before :each do
-        @result = true.to_yaml
-        @searcher.stubs(:network_delete).returns(@result)  # neuter the network connection
-        @model.stubs(:from_yaml).returns(@instance)
-
-        @request = stub 'request', :key => 'foo'
-      end
-      
-      it "should look up the model instance over the network" do
-        @searcher.expects(:network_delete).returns(@result)
-        @searcher.destroy(@request)
-      end
-      
-      it "should look up the model instance using the named indirection" do
-        @searcher.expects(:network_delete).with {|path| path =~ %r{^#{@indirection.name.to_s}/} }.returns(@result)
-        @searcher.destroy(@request)
-      end
-      
-      it "should look up the model instance using the provided key" do
-        @searcher.expects(:network_delete).with {|path| path =~ %r{/foo$} }.returns(@result)
-        @searcher.destroy(@request)
-      end
-      
-      it "should deserialize result data" do
-        YAML.expects(:load).with(@result)
-        @searcher.destroy(@request)
-      end
-      
-      it "should return deserialized result data" do
-        @searcher.destroy(@request).should == true
-      end
-      
-      it "should generate an error when result data specifies an error" do
-        @searcher.stubs(:network_delete).returns(RuntimeError.new("bogus").to_yaml)
-        lambda { @searcher.destroy(@request) }.should raise_error(RuntimeError)        
-      end      
+        before :each do
+            @connection = stub('mock http connection', :delete => @response)
+            @searcher.stubs(:network).returns(@connection)    # neuter the network connection
+
+            @request = Puppet::Indirector::Request.new(:foo, :destroy, "foo bar")
+        end
+
+        it "should call the DELETE http method on a network connection" do
+            @searcher.expects(:network).returns @connection
+            @connection.expects(:delete).returns @response
+            @searcher.destroy(@request)
+        end
+
+        it "should fail if any options are provided, since DELETE apparently does not support query options" do
+            @request.stubs(:options).returns(:one => "two", :three => "four")
+
+            lambda { @searcher.destroy(@request) }.should raise_error(ArgumentError)
+        end
+
+        it "should deserialize and return the http response" do
+            @connection.expects(:delete).returns @response
+            @searcher.expects(:deserialize).with(@response).returns "myobject"
+
+            @searcher.destroy(@request).should == 'myobject'
+        end
+
+        it "should use the URI generated by the Handler module" do
+            @searcher.expects(:indirection2uri).with(@request).returns "/my/uri"
+            @connection.expects(:delete).with { |path, args| path == "/my/uri" }.returns(@response)
+            @searcher.destroy(@request)
+        end
+
+        it "should not include the query string" do
+            @connection.stubs(:delete).returns @response
+            @searcher.destroy(@request)
+        end
+
+        it "should provide an Accept header containing the list of supported formats joined with commas" do
+            @connection.expects(:delete).with { |path, args| args["Accept"] == "supported, formats" }.returns(@response)
+
+            @searcher.model.expects(:supported_formats).returns %w{supported formats}
+            @searcher.destroy(@request)
+        end
+
+        it "should deserialize and return the network response" do
+            @searcher.expects(:deserialize).with(@response).returns @instance
+            @searcher.destroy(@request).should equal(@instance)
+        end
+
+        it "should generate an error when result data deserializes fails" do
+            @searcher.expects(:deserialize).raises(ArgumentError)
+            lambda { @searcher.destroy(@request) }.should raise_error(ArgumentError)
+        end
     end
 
     describe "when doing a save" do
-      before :each do
-        @result = { :foo => 'bar'}.to_yaml
-        @searcher.stubs(:network_put).returns(@result)  # neuter the network connection
-        @model.stubs(:from_yaml).returns(@instance)
-
-        @request = stub 'request', :instance => @instance
-      end
-      
-      it "should save the model instance over the network" do
-        @searcher.expects(:network_put).returns(@result)
-        @searcher.save(@request)
-      end
-      
-      it "should save the model instance using the named indirection" do
-        @searcher.expects(:network_put).with do |path, data| 
-          path =~ %r{^#{@indirection.name.to_s}/} and 
-          data == @instance.to_yaml 
-        end.returns(@result)
-        @searcher.save(@request)
-      end
-      
-      it "should deserialize result data to a Model instance" do
-        @model.expects(:from_yaml)
-        @searcher.save(@request)
-      end
-      
-      it "should return the resulting deserialized Model instance" do
-        @searcher.save(@request).should == @instance     
-      end
-      
-      it "should return nil when deserialized model instance is nil" do
-        @model.stubs(:from_yaml).returns(nil)
-        @searcher.save(@request).should be_nil
-      end
-      
-      it "should generate an error when result data deserializes improperly" do
-        @model.stubs(:from_yaml).raises(ArgumentError)
-        lambda { @searcher.save(@request) }.should raise_error(ArgumentError)
-      end
-      
-      it "should generate an error when result data specifies an error" do
-        @searcher.stubs(:network_put).returns(RuntimeError.new("bogus").to_yaml)
-        lambda { @searcher.save(@request) }.should raise_error(RuntimeError)        
-      end      
+        before :each do
+            @connection = stub('mock http connection', :put => @response)
+            @searcher.stubs(:network).returns(@connection)    # neuter the network connection
+
+            @instance = stub 'instance', :render => "mydata", :mime => "mime"
+            @request = Puppet::Indirector::Request.new(:foo, :save, "foo bar")
+            @request.instance = @instance
+        end
+
+        it "should call the PUT http method on a network connection" do
+            @searcher.expects(:network).returns @connection
+            @connection.expects(:put).returns @response
+            @searcher.save(@request)
+        end
+
+        it "should fail if any options are provided, since DELETE apparently does not support query options" do
+            @request.stubs(:options).returns(:one => "two", :three => "four")
+
+            lambda { @searcher.save(@request) }.should raise_error(ArgumentError)
+        end
+
+        it "should use the URI generated by the Handler module" do
+            @searcher.expects(:indirection2uri).with(@request).returns "/my/uri"
+            @connection.expects(:put).with { |path, args| path == "/my/uri" }.returns(@response)
+            @searcher.save(@request)
+        end
+
+        it "should serialize the instance using the default format and pass the result as the body of the request" do
+            @instance.expects(:render).returns "serial_instance"
+            @connection.expects(:put).with { |path, data, args| data == "serial_instance" }.returns @response
+
+            @searcher.save(@request)
+        end
+
+        it "should deserialize and return the http response" do
+            @connection.expects(:put).returns @response
+            @searcher.expects(:deserialize).with(@response).returns "myobject"
+
+            @searcher.save(@request).should == 'myobject'
+        end
+
+        it "should provide an Accept header containing the list of supported formats joined with commas" do
+            @connection.expects(:put).with { |path, data, args| args["Accept"] == "supported, formats" }.returns(@response)
+
+            @searcher.model.expects(:supported_formats).returns %w{supported formats}
+            @searcher.save(@request)
+        end
+
+        it "should provide a Content-Type header containing the mime-type of the sent object" do
+            @connection.expects(:put).with { |path, data, args| args['Content-Type'] == "mime" }.returns(@response)
+
+            @instance.expects(:mime).returns "mime"
+            @searcher.save(@request)
+        end
+
+        it "should deserialize and return the network response" do
+            @searcher.expects(:deserialize).with(@response).returns @instance
+            @searcher.save(@request).should equal(@instance)
+        end
+
+        it "should generate an error when result data deserializes fails" do
+            @searcher.expects(:deserialize).raises(ArgumentError)
+            lambda { @searcher.save(@request) }.should raise_error(ArgumentError)
+        end
     end
 end