wrest 0.0.9-java → 0.1.0-java

data/spec/unit/wrest/components/attributes_container_spec.rb

@@ -10,18 +10,54 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 module Wrest::Components
-  describe AttributesContainer do
+  describe Container do
     class HumanBeing
-      include Wrest::Components::AttributesContainer
+      include Wrest::Components::Container
       always_has :id
     end
 
+    class WaterMagician < HumanBeing
+    end
+
+    it "should allow instantiation with no attributes" do
+      lambda{ HumanBeing.new }.should_not raise_error
+    end
+
+    describe 'serialisation' do
+      it "should know its xml element name" do
+        HumanBeing.element_name.should == 'human_being'
+      end
+
+      it "should know how to serialise itself given any of the Wrest::Components::Translators" do
+        result = HumanBeing.new(:age => "70", :name => 'Li Piao').serialise_using(Wrest::Components::Translators::Json)
+        expectedPermutationOne = "{\"age\":\"70\",\"name\":\"Li Piao\"}"
+        expectedPermutationTwo = "{\"name\":\"Li Piao\",\"age\":\"70\"}"
+        
+        (result == expectedPermutationOne || result == expectedPermutationTwo).should be_true
+      end
+
+      it "should have a to_xml helper that ensures that the name of the class is the root of the serilised form" do
+        result = HumanBeing.new(:age => "70", :name => 'Li Piao').to_xml
+        expectedPermutationOne = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<human-being>\n  <age>70</age>\n  <name>Li Piao</name>\n</human-being>\n"
+        expectedPermutationTwo = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<human-being>\n  <name>Li Piao</name>\n  <age>70</age>\n</human-being>\n"
+
+        (result == expectedPermutationOne || result == expectedPermutationTwo).should be_true
+      end
+
+      describe 'subclasses' do
+        it "should not allow cached element name to clash" do
+          WaterMagician.element_name.should == 'water_magician'
+          HumanBeing.element_name.should == 'human_being'
+        end
+      end
+    end
+
     describe "typecasting" do
       before(:each) do
         @Demon = Class.new
 
         @Demon.class_eval do
-          include Wrest::Components::AttributesContainer
+          include Wrest::Components::Container
         end
       end
 
@@ -31,7 +67,7 @@ module Wrest::Components
         end
         @Demon.new(:foo => '1').foo.should == 1
       end
-      
+
       it "should provide helpers for common typecasts" do
         @Demon.class_eval do
           typecast :foo => as_integer
@@ -40,10 +76,6 @@ module Wrest::Components
       end
     end
 
-    it "should allow instantiation with no attributes" do
-      lambda{ HumanBeing.new }.should_not raise_error
-    end
-
     describe 'always_has' do
       describe 'method creation' do
         before :each do
@@ -57,7 +89,7 @@ module Wrest::Components
           kai_wren.methods.map(&:to_sym).should_not include(:trainer)
 
           @Demon.class_eval{
-            include Wrest::Components::AttributesContainer
+            include Wrest::Components::Container
             always_has :trainer
           }
 
@@ -69,7 +101,7 @@ module Wrest::Components
           kai_wren.methods.map(&:to_sym).should_not include(:trainer=)
 
           @Demon.class_eval{
-            include Wrest::Components::AttributesContainer
+            include Wrest::Components::Container
             always_has :trainer
           }
 
@@ -81,7 +113,7 @@ module Wrest::Components
           kai_wren.methods.map(&:to_sym).should_not include(:trainer?)
 
           @Demon.class_eval{
-            include Wrest::Components::AttributesContainer
+            include Wrest::Components::Container
             always_has :trainer
           }
           kai_wren.methods.map(&:to_sym).should include(:trainer?)
@@ -92,7 +124,7 @@ module Wrest::Components
         before :each do
           @Demon = Class.new
           @Demon.class_eval{
-            include Wrest::Components::AttributesContainer
+            include Wrest::Components::Container
             always_has :trainer
 
             def method_missing(method_name, *args)

data/spec/unit/wrest/components/translators/xml_spec.rb

@@ -1,12 +1,16 @@
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 module Wrest::Components::Translators
-  describe Xml do  
+  describe Xml do
     it "should know how to convert xml to a hashmap" do
       http_response = mock('Http Reponse')
       http_response.should_receive(:body).and_return("<ooga><age>12</age></ooga>")
 
-      Xml.deserialise(http_response).should == {"ooga"=>{"age"=>{"__content__" => "12"}}}
+      Xml.deserialise(http_response).should == {"ooga"=>{"age"=> "12"}}
+    end
+
+    it "should know how to convert a hashmap to xml" do
+      Xml.serialise({"ooga"=>{"age" => "12"}}).should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<hash>\n  <ooga>\n    <age>12</age>\n  </ooga>\n</hash>\n"
     end
   end
-end
+end

data/spec/unit/wrest/curl/request_spec.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+unless RUBY_PLATFORM =~ /java/
+  module Wrest
+    describe Curl::Request do
+      before :all do
+        Wrest.use_curl
+      end
+
+      it "should raise an exception if an options is invoked" do
+        lambda{ 'http://localhost:3000/bottles'.to_uri.options }.should raise_error(Wrest::Exceptions::UnsupportedHttpVerb)
+      end
+
+      after :all do
+        Wrest.use_native
+      end
+    end
+  end
+end

data/spec/unit/wrest/curl/response_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+unless RUBY_PLATFORM =~ /java/
+  module Wrest
+    describe Curl::Response do
+      describe 'Headers' do
+        it "should know how to retrieve content type irrespective of the casing" do
+          http_response = mock('Patron::Response')
+          http_response.stub!(:headers).and_return({'Content-type' => 'text/xml;charset=utf-8'})
+          response = Wrest::Curl::Response.new(http_response)
+          response.content_type.should == 'text/xml'
+        end
+      end
+    end
+  end
+end

data/spec/unit/wrest/http/response_spec.rb

@@ -1,45 +1,24 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 module Wrest
-  describe Http::Response do
-    it "should build a Redirection instead of a normal response if the code is 3xx" do
-      http_response = mock(Net::HTTPRedirection)
-      http_response.stub!(:code).and_return('301')
-      
-      Http::Response.new(http_response).class.should == Wrest::Http::Redirection
-    end
-    
-    it "should build a normal Response for non 3xx codes" do
-      http_response = mock(Net::HTTPResponse)
-      http_response.stub!(:code).and_return('200')
-      
-      Http::Response.new(http_response).class.should == Wrest::Http::Response
-    end
-    
-    it "should know how to delegate to a translator" do
-      http_response = mock('response')
-      http_response.stub!(:code).and_return('200')
-      Components::Translators::Xml.should_receive(:deserialise).with(http_response)
-      Http::Response.new(http_response).deserialise_using(Components::Translators::Xml)
-    end
-
-    it "should know how to load a translator based on content type" do
-      http_response = mock('response')
-      http_response.stub!(:code).and_return('422')
-      http_response.should_receive(:content_type).and_return('application/xml')
-
-      response = Http::Response.new(http_response)
-      response.should_receive(:deserialise_using).with(Components::Translators::Xml)
-
-      response.deserialise
-    end
+  libraries = [Wrest::Native]
+  libraries << Wrest::Curl unless RUBY_PLATFORM =~ /java/
     
-    it "should simply return itself when asked to follow (null object behaviour - see MovedPermanently for more context)" do
-      http_response = mock('response')
-      http_response.stub!(:code).and_return('422')
-      
-      response = Http::Response.new(http_response)
-      response.follow.equal?(response).should be_true
+  libraries.each do |library|
+    describe "For #{library}" do
+      describe 'Response' do
+        describe 'Headers' do
+          it "should know how to retrieve content type irrespective of the casing" do
+            http_response = mock('Response')
+            http_response.stub!(:headers).and_return({'Content-type' => 'application/xml'})
+            http_response.stub!(:code).and_return('200')
+            http_response.stub!(:content_type).and_return('application/xml')
+            
+            response = library::Response.new(http_response)
+            response.content_type.should == 'application/xml'
+          end
+        end
+      end
     end
   end
 end

data/spec/unit/wrest/{http → native}/redirection_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe Wrest::Http::Redirection do
+describe Wrest::Native::Redirection do
   
   it "should make a request to the url in its location header and return the response" do
     mock_net_http_response = mock(Net::HTTPRedirection)
@@ -12,13 +12,13 @@ describe Wrest::Http::Redirection do
     Wrest::Uri.should_receive(:new).with(redirect_url, anything).and_return(redirect_uri)
     
     
-    after_redirect_request = Wrest::Http::Get.new(redirect_uri)
-    final_mock_response = mock(Wrest::Http::Response)
+    after_redirect_request = Wrest::Native::Get.new(redirect_uri)
+    final_mock_response = mock(Wrest::Native::Response)
     after_redirect_request.should_receive(:invoke).and_return(final_mock_response)
     
-    Wrest::Http::Get.should_receive(:new).with(redirect_uri, {}, {}, {:username=>nil, :password=>nil}).and_return(after_redirect_request)
+    Wrest::Native::Get.should_receive(:new).with(redirect_uri, {}, {}, {:username=>nil, :password=>nil}).and_return(after_redirect_request)
     
-    response = Wrest::Http::Redirection.new(mock_net_http_response)
+    response = Wrest::Native::Redirection.new(mock_net_http_response)
     response.follow(:follow_redirects_count => 0, :follow_redirects_limit => 5).should == final_mock_response
   end
   

data/spec/unit/wrest/{http → native}/request_spec.rb

@@ -9,9 +9,9 @@
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe Wrest::Http::Request do
+describe Wrest::Native::Request do
   it "should convert all symbols in header keys to strings" do
-    Wrest::Http::Request.new(
+    Wrest::Native::Request.new(
                 'http://localhost/foo'.to_uri, Net::HTTP::Get, {}, 
                 nil, 'Content-Type' => 'application/xml', :per_page => '10'
                 ).headers.should == {
@@ -21,28 +21,29 @@ describe Wrest::Http::Request do
   end
   
   it "should default the 'follow_redirects' option to true for a Get" do
-    Wrest::Http::Get.new('http://localhost/foo'.to_uri).follow_redirects.should be_true
+    Wrest::Native::Get.new('http://localhost/foo'.to_uri).follow_redirects.should be_true
   end
   
   it "should default the 'follow_redirects_count' option to 0" do
-    Wrest::Http::Get.new('http://localhost/foo'.to_uri).follow_redirects_count.should == 0
+    Wrest::Native::Get.new('http://localhost/foo'.to_uri).follow_redirects_count.should == 0
   end
   
   it "should default the 'follow_redirects_limit' option to 5" do
-    Wrest::Http::Get.new('http://localhost/foo'.to_uri).follow_redirects_limit.should == 5
+    Wrest::Native::Get.new('http://localhost/foo'.to_uri).follow_redirects_limit.should == 5
   end
   
   it "should allow Gets to disable redirect follows" do
-    Wrest::Http::Get.new('http://localhost/foo'.to_uri, {}, {}, {:follow_redirects => false}).follow_redirects.should be_false
+    Wrest::Native::Get.new('http://localhost/foo'.to_uri, {}, {}, {:follow_redirects => false}).follow_redirects.should be_false
   end
   
   it "should increment the follow_redirects_count for every redirect leving the count unaffected in previous requests" do
-    request = Wrest::Http::Get.new('http://localhost/foo'.to_uri)
+    uri = 'http://localhost/foo'.to_uri
+    request = Wrest::Native::Get.new(uri)
     redirect_location = 'http://coathangers.com'
     redirected_request = mock('Request to http://coathangers.com')
 
     mock_connection = mock('Http Connection')
-    request.stub!(:create_connection).and_return(mock_connection)
+    uri.stub!(:create_connection).and_return(mock_connection)
     
     raw_response = mock(Net::HTTPRedirection)
     raw_response.stub!(:code).and_return('301')
@@ -50,11 +51,11 @@ describe Wrest::Http::Request do
     raw_response.stub!(:body).and_return('')
     raw_response.stub!(:[]).with('location').and_return(redirect_location)
     
-    response = Wrest::Http::Redirection.new(raw_response)
+    response = Wrest::Native::Redirection.new(raw_response)
     
     mock_connection.should_receive(:request).and_return(raw_response)
     
-    Wrest::Http::Response.should_receive(:new).and_return(response)
+    Wrest::Native::Response.should_receive(:new).and_return(response)
     redirected_request.stub!(:get)
     redirect_location.should_receive(:to_uri).with(hash_including(:follow_redirects_count=>1)).and_return(redirected_request)
     
@@ -63,8 +64,8 @@ describe Wrest::Http::Request do
   end
   
   it "should default the 'follow_redirects' option to false for a Post, Put or Delete" do
-    Wrest::Http::Post.new('http://localhost/foo'.to_uri).follow_redirects.should_not be_true
-    Wrest::Http::Put.new('http://localhost/foo'.to_uri).follow_redirects.should_not be_true
-    Wrest::Http::Delete.new('http://localhost/foo'.to_uri).follow_redirects.should_not be_true
-  end
+    Wrest::Native::Post.new('http://localhost/foo'.to_uri).follow_redirects.should_not be_true
+    Wrest::Native::Put.new('http://localhost/foo'.to_uri).follow_redirects.should_not be_true
+    Wrest::Native::Delete.new('http://localhost/foo'.to_uri).follow_redirects.should_not be_true
+  end  
 end

data/spec/unit/wrest/native/response_spec.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Wrest
+  describe Native::Response do
+    it "should build a Redirection instead of a normal response if the code is 301..303 or 305..3xx" do
+      http_response = mock(Net::HTTPRedirection)
+      http_response.stub!(:code).and_return('301')
+      
+      Native::Response.new(http_response).class.should == Wrest::Native::Redirection
+    end
+
+    it "should build a normal response if the code is 304" do
+      http_response = mock(Net::HTTPRedirection)
+      http_response.stub!(:code).and_return('304')
+      
+      Native::Response.new(http_response).class.should == Wrest::Native::Response
+    end
+    
+    it "should build a normal Response for non 3xx codes" do
+      http_response = mock(Net::HTTPResponse)
+      http_response.stub!(:code).and_return('200')
+      
+      Native::Response.new(http_response).class.should == Wrest::Native::Response
+    end
+    
+    it "should know how to delegate to a translator" do
+      http_response = mock('response')
+      http_response.stub!(:code).and_return('200')
+      Components::Translators::Xml.should_receive(:deserialise).with(http_response)
+      Native::Response.new(http_response).deserialise_using(Components::Translators::Xml)
+    end
+
+    it "should know how to load a translator based on content type" do
+      http_response = mock('response')
+      http_response.stub!(:code).and_return('422')
+      http_response.should_receive(:content_type).and_return('application/xml')
+
+      response = Native::Response.new(http_response)
+      response.should_receive(:deserialise_using).with(Components::Translators::Xml)
+
+      response.deserialise
+    end
+    
+    it "should simply return itself when asked to follow (null object behaviour - see MovedPermanently for more context)" do
+      http_response = mock('response')
+      http_response.stub!(:code).and_return('422')
+      
+      response = Native::Response.new(http_response)
+      response.follow.equal?(response).should be_true
+    end
+    
+    describe 'Keep-Alive' do
+      it "should know when a connection has been closed" do
+        http_response = mock('response')
+        http_response.stub!(:code).and_return('200')
+        http_response.should_receive(:[]).with(Wrest::H::Connection).and_return('Close')
+    
+        response = Native::Response.new(http_response)
+        response.should be_connection_closed
+      end
+      
+      it "should know when a keep-alive connection has been estalished" do
+        http_response = mock('response')
+        http_response.stub!(:code).and_return('200')
+        http_response.should_receive(:[]).with(Wrest::H::Connection).and_return('')
+    
+        response = Native::Response.new(http_response)
+        response.should_not be_connection_closed
+      end
+    end
+  end
+end

data/spec/unit/wrest/native/session_spec.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Wrest
+  describe Native::Session do
+    describe 'Construction' do
+      it "should accept a string uri and convert it to a Wrest::Uri" do
+        uri = "http://localhost:3000"
+        Native::Session.new(uri).uri.should == uri.to_uri
+      end
+      
+      it "should accept a Wrest::Uri" do
+        uri = "http://localhost:3000"
+        Native::Session.new(uri.to_uri).uri.should == uri.to_uri
+      end      
+    end
+
+    it "should know how to use the connection provided to make requests" do
+      uri = "http://localhost:3000".to_uri
+      uri.should_not be_https
+
+      http = mock(Net::HTTP)
+      Net::HTTP.should_receive(:new).with('localhost', 3000).and_return(http)
+      http.should_receive(:read_timeout=).with(60)
+
+      request_one = Net::HTTP::Get.new('/glassware?owner=Kai&type=bottle', {H::Connection=>T::KeepAlive})
+      request_two = Net::HTTP::Get.new('/bottles.xml', {H::Connection=>T::KeepAlive})
+
+      Net::HTTP::Get.should_receive(:new).with('/glassware?owner=Kai&type=bottle', {H::Connection=>T::KeepAlive}).and_return(request_one)
+      Net::HTTP::Get.should_receive(:new).with('/bottles.xml', {H::Connection=>T::KeepAlive}).and_return(request_two)
+
+      ok_response = build_ok_response
+      ok_response.should_receive(:[]).with(Native::StandardHeaders::Connection).twice.and_return(Native::StandardTokens::KeepAlive)
+      
+      http.should_receive(:request).with(request_one, nil).and_return(ok_response)
+      http.should_receive(:request).with(request_two, nil).and_return(ok_response)
+
+      Native::Session.new(uri) do |session|
+        session.get('/glassware', :owner => 'Kai', :type => 'bottle')
+        session.get '/bottles.xml'
+      end
+    end
+    
+    it "should destroy the current connection if a response is returned with a Connection: Close" do
+      uri = "http://localhost:3000".to_uri
+      uri.should_not be_https
+
+      http = mock(Net::HTTP)
+      Net::HTTP.should_receive(:new).with('localhost', 3000).and_return(http)
+      http.should_receive(:read_timeout=).with(60)
+
+      request_one = Net::HTTP::Get.new('/glassware?owner=Kai&type=bottle', {H::Connection=>T::KeepAlive})
+      request_two = Net::HTTP::Get.new('/bottles.xml', {H::Connection=>T::KeepAlive})
+
+      Net::HTTP::Get.should_receive(:new).with('/glassware?owner=Kai&type=bottle', {H::Connection=>T::KeepAlive}).and_return(request_one)
+      Net::HTTP::Get.should_receive(:new).with('/bottles.xml', {H::Connection=>T::KeepAlive}).and_return(request_two)
+
+      ok_response = build_ok_response
+      ok_response.should_receive(:[]).with(Native::StandardHeaders::Connection).once.and_return(Native::StandardTokens::KeepAlive)
+
+      ok_response_with_connection_close = build_ok_response
+      ok_response_with_connection_close.should_receive(:[]).with(Native::StandardHeaders::Connection).once.and_return(Native::StandardTokens::Close)
+      
+      http.should_receive(:request).with(request_one, nil).and_return(ok_response)
+      http.should_receive(:request).with(request_two, nil).and_return(ok_response_with_connection_close)
+
+      Native::Session.new(uri) do |session|
+        session.get('/glassware', :owner => 'Kai', :type => 'bottle')
+        session.instance_variable_get('@connection').should == http
+        session.get '/bottles.xml'
+        session.instance_variable_get('@connection').should be_nil
+      end
+    end
+  end
+end

data/spec/unit/wrest/resource/base_spec.rb

@@ -165,7 +165,7 @@ module Wrest
         it "should know how to find a resource by id" do
           uri = 'http://localhost:3001/bottled_universe/1.xml'.to_uri
           Wrest::Uri.should_receive(:new).with('http://localhost:3001/bottled_universes/1.xml', {}).and_return(uri)
-          response = mock(Wrest::Http::Response)
+          response = mock(Wrest::Native::Response)
           uri.should_receive(:get).with(no_args).and_return(response)
           response.should_receive(:deserialise).and_return({"bottled-universe"=>{"name"=>{"__content__"=>"Wooz"}, "universe-id"=>{"type"=>"integer", "nil"=>"true"}, "id"=>{"__content__"=>"1", "type"=>"integer"}}})
 
@@ -196,7 +196,7 @@ module Wrest
         uri.should_receive(:post).with(
                                       "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bottled-universe>\n  <name>Woot</name>\n</bottled-universe>\n", 
                                       'Content-Type' => 'application/xml'
-                                      ).and_return(Wrest::Http::Response.new(mock_http_response))
+                                      ).and_return(Wrest::Native::Response.new(mock_http_response))
         ware = BottledUniverse.create(:name => 'Woot')
       end
     end

data/spec/unit/wrest/uri_spec.rb

@@ -11,14 +11,6 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 module Wrest
   describe Wrest::Uri do
-    def build_ok_response(body = '')
-      returning mock(Net::HTTPOK) do |response|
-        response.stub!(:code).and_return('200')
-        response.stub!(:message).and_return('OK')
-        response.stub!(:body).and_return(body)
-      end
-    end
-
     it "should respond to the four http actions" do
       uri = Uri.new('http://localhost')
       uri.should respond_to(:get)
@@ -38,7 +30,7 @@ module Wrest
     it "should know how to build a new uri from an existing one by appending a path" do
       Uri.new('http://localhost:3000')['/ooga/booga'].should == Uri.new('http://localhost:3000/ooga/booga')
     end
-    
+
     it "should know its full path" do
       Uri.new('http://localhost:3000/ooga').full_path.should == '/ooga'
       Uri.new('http://localhost:3000/ooga?foo=meh&bar=1').full_path.should == '/ooga?foo=meh&bar=1'
@@ -47,12 +39,12 @@ module Wrest
     it "should know its host" do
       Uri.new('http://localhost:3000/ooga').host.should == 'localhost'
     end
-  
+
     it "should know its port" do
       Uri.new('http://localhost:3000/ooga').port.should == 3000
       Uri.new('http://localhost/ooga').port.should == 80
     end
-  
+
     it "should include the username and password while building a new uri if no options are provided" do
       Uri.new(
         'http://localhost:3000', 
@@ -73,6 +65,13 @@ module Wrest
       extended_uri.password.should == 'baz'
     end
     
+    it "should know how to produce its uri as a string" do
+      Uri.new('http://localhost:3000').uri_string.should == 'http://localhost:3000'
+      Uri.new('http://localhost:3000').to_s.should == 'http://localhost:3000'
+      Uri.new('http://localhost:3000', :username => 'foo', :password => 'bar').to_s.should == 'http://localhost:3000'
+      Uri.new('http://foo:bar@localhost:3000').to_s.should == 'http://foo:bar@localhost:3000'
+    end
+    
     describe 'Equals' do
       it "should understand equality" do
         Uri.new('https://localhost:3000/ooga').should_not == nil
@@ -105,6 +104,29 @@ module Wrest
       end
     end
     
+    describe 'Cloning' do
+      before :each do
+        @original = Uri.new('http://localhost:3000/ooga')
+        @clone = @original.clone        
+      end
+      
+      it "should be equal to its clone" do
+        @original.should == @clone
+      end
+      
+      it "should not be the same object as the clone" do
+        @original.should_not be_equal(@clone)
+      end
+      
+      it "should allow options to be changed when building the clone" do
+        clone = @original.clone(:username => 'kaiwren', :password => 'bottle')
+        @original.should_not == clone
+        clone.username.should == 'kaiwren'
+        clone.password.should == 'bottle'
+        @original.username.should be_nil
+      end
+    end
+    
     describe 'HTTP actions' do
       def setup_http
         returning mock(Net::HTTP) do |http|
@@ -168,6 +190,24 @@ module Wrest
 
         uri.post '<ooga>Booga</ooga>', :page => '2', :per_page => '5'
       end
+      
+      it "should know how to post form-encoded parameters using Uri#post_form" do
+        uri = "http://localhost:3000/glassware".to_uri
+        uri.should_not be_https
+
+        http = setup_http
+
+        request = Net::HTTP::Post.new('/glassware', {'page' => '2', 'per_page' => '5'})
+        Net::HTTP::Post.should_receive(:new).with('/glassware', 
+                                                  'page' => '2', 'per_page' => '5', H::ContentType=>T::FormEncoded
+                                                  ).and_return(request)
+
+        http.should_receive(:request).with(request, "foo=bar&ooga=booga").and_return(build_ok_response)
+        params = ActiveSupport::OrderedHash.new
+        params[:ooga] = 'booga'
+        params[:foo] = 'bar'
+        uri.post_form(params, :page => '2', :per_page => '5')
+      end
 
       it "should know how to put" do
         uri = "http://localhost:3000/glassware".to_uri