wrest 1.0.0.beta1 → 1.0.0.beta2

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

@@ -1,42 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-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)
-    redirect_url = 'http://redirect.com'
-    redirect_uri = redirect_url.to_uri
-    mock_net_http_response.should_receive(:[]).with('location').and_return(redirect_url)
-    mock_net_http_response.should_receive(:code).and_return('200')
-    
-    Wrest::Uri.should_receive(:new).with(redirect_url, anything).and_return(redirect_uri)
-    
-    
-    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::Native::Get.should_receive(:new).with(redirect_uri, {}, {}, {:username=>nil, :password=>nil}).and_return(after_redirect_request)
-    
-    response = Wrest::Native::Redirection.new(mock_net_http_response)
-    response.follow(:follow_redirects_count => 0, :follow_redirects_limit => 5).should == final_mock_response
-  end
-  
-  it "should raise a Wrest::Exceptions::AutoRedirectLimitExceeded if there are more redirections than the limit" do
-    request_url = 'http://redirect.com'
-
-    response = mock(Net::HTTPRedirection)
-    response.stub!(:code).and_return('301')
-    response.stub!(:message).and_return('')
-    response.stub!(:body).and_return('')
-    response.should_receive(:[]).with('location').exactly(5).times.and_return(request_url)
-    
-    http_connection = mock(Net::HTTP)
-    http_connection.stub!(:read_timeout=)
-    http_connection.should_receive(:request).exactly(5).times.and_return(response)
-    
-    Net::HTTP.should_receive(:new).exactly(5).times.and_return(http_connection)
-
-    lambda{ request_url.to_uri(:follow_redirects_limit => 5).get }.should raise_error(Wrest::Exceptions::AutoRedirectLimitExceeded)
-  end
-end

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

@@ -1,71 +0,0 @@
-# Copyright 2009 Sidu Ponnappa
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-# Unless required by applicable law or agreed to in writing, software distributed under the License
-# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and limitations under the License.
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe Wrest::Native::Request do
-  it "should convert all symbols in header keys to strings" do
-    Wrest::Native::Request.new(
-                'http://localhost/foo'.to_uri, Net::HTTP::Get, {}, 
-                nil, 'Content-Type' => 'application/xml', :per_page => '10'
-                ).headers.should == {
-                  'Content-Type' => 'application/xml',
-                  'per_page' => '10'
-                }
-  end
-  
-  it "should default the 'follow_redirects' option to true for a Get" do
-    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::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::Native::Get.new('http://localhost/foo'.to_uri).follow_redirects_limit.should == 5
-  end
-  
-  it "should allow Gets to disable redirect follows" do
-    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
-    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')
-    uri.stub!(:create_connection).and_return(mock_connection)
-    
-    raw_response = mock(Net::HTTPRedirection)
-    raw_response.stub!(:code).and_return('301')
-    raw_response.stub!(:message).and_return('')
-    raw_response.stub!(:body).and_return('')
-    raw_response.stub!(:[]).with('location').and_return(redirect_location)
-    
-    response = Wrest::Native::Redirection.new(raw_response)
-    
-    mock_connection.should_receive(:request).and_return(raw_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)
-    
-    request.invoke
-    request.follow_redirects_count.should == 0
-  end
-  
-  it "should default the 'follow_redirects' option to false for a Post, Put or Delete" do
-    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

@@ -1,72 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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', ActiveSupport::OrderedHash.new.merge!([[: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', ActiveSupport::OrderedHash.new.merge!([[: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

@@ -1,274 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-class Glassware < Wrest::Resource::Base
-  set_host "http://localhost:3000"
-end
-
-class BottledUniverse < Glassware
-  set_host            "http://localhost:3001"
-  set_default_format  :xml
-end
-
-module Wrest
-  describe Wrest::Resource::Base do
-    it "should not affect other classes when setting up its macros" do
-      Class.should_not respond_to(:host=)
-      Object.should_not respond_to(:host=)
-    end
-
-    it "should not affect itself when subclasses use its macros" do
-      Resource::Base.should_not respond_to(:host)
-    end
-
-    describe 'subclasses' do
-      before(:each) do
-        @BottledUniverse = Class.new(Wrest::Resource::Base)
-        @BottledUniverse.class_eval do
-          set_resource_name 'BottledUniverse'
-        end
-      end
-
-      describe 'equality' do
-        it "should be equal if it is the same instance" do
-          universe = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
-          (universe == universe).should be_true
-        end
-
-        it "should be equal if it has the same state" do
-          (
-          @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1) == @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
-          ).should be_true
-        end
-
-        it "should not be equal to nil" do
-          (@BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1) == nil).should be_false
-        end
-
-        it "should not be equal if it is not the same class" do
-          (
-          @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1) == Glassware.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
-          ).should be_false
-        end
-
-        it "should not be equal if it is has a different state" do
-          (
-          @BottledUniverse.new(:universe_id=>3, :name=>"Wooz", :id=>1) == @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
-          ).should be_false
-        end
-
-        it "should be symmetric" do
-          universe_one = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
-          universe_two = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
-          (universe_one == universe_one).should be_true
-          (universe_two == universe_two).should be_true
-        end
-
-        it "should be transitive" do
-          universe_one = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
-          universe_two = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
-          universe_three = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
-          (universe_one == universe_two).should be_true
-          (universe_two == universe_three).should be_true
-          (universe_one == universe_three).should be_true
-        end
-
-        it "should ensure that the hashcode is a fixnum" do
-          @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1).hash.should be_kind_of(Fixnum)
-        end
-
-        it "should ensure that instances with the same ids have the same hashcode" do
-          universe_one = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
-          universe_two = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
-          universe_one.hash.should == universe_two.hash
-        end
-
-        it "should ensure that instances with different ids have the different hashcodes" do
-          universe_one = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
-          universe_two = @BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>2)
-          universe_one.hash.should_not == universe_two.hash
-        end
-      end
-
-      it "should know its name as a resource by default" do
-        BottledUniverse.resource_name.should == 'bottled_universe'
-      end
-
-      it "should allow its name as a resource to be configured for anonymous classes" do
-        @BottledUniverse.resource_name.should == 'bottled_universe'
-      end
-
-      it "should know how to create an instance using deserialised attributes" do
-        universe = @BottledUniverse.new "name"=>"Wooz", "id"=>'1', "universe_id"=>nil, 'owner_id'=>nil
-        universe.name.should == "Wooz"
-        universe.owner_id.should be_nil
-        universe.id.should == 1
-      end
-
-      it "should allow instantiation with no attributes" do
-        lambda{ @BottledUniverse.new }.should_not raise_error
-      end
-
-      it "should have a method to set the host url" do
-        @BottledUniverse.should respond_to(:set_host)
-      end
-
-      it "should have a method to retrive the host url after it is set" do
-        @BottledUniverse.class_eval{ set_host "http://localhost:3000" }
-        @BottledUniverse.should respond_to(:host)
-      end
-
-      it "should know what its site is" do
-        @BottledUniverse.class_eval{ set_host "http://localhost:3000" }
-        @BottledUniverse.host.should == "http://localhost:3000"
-      end
-
-      it "should not use the same string" do
-        url = "http://localhost:3000"
-        @BottledUniverse.class_eval{ set_host  url }
-        url.upcase!
-        @BottledUniverse.host.should == "http://localhost:3000"
-      end
-
-      it "should know its resource collection name" do
-        Glassware.resource_collection_name.should == 'glasswares'
-      end
-
-      it "should know its uri template for find one" do
-        Glassware.find_one_uri_template.to_uri(
-          :host => 'http://localhost:3000', 
-          :resource_collection_name => 'glasswares',
-          :id => 1,
-          :format => 'json'
-        ).should == 'http://localhost:3000/glasswares/1.json'.to_uri
-      end
-
-      it "should know how to serialise itself to xml" do
-        BottledUniverse.new(:name => 'Foo').to_xml.should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bottled-universe>\n  <name>Foo</name>\n</bottled-universe>\n"
-      end
-            
-      describe 'finders' do
-        # Json =>
-        #         body => {"lead_bottle": {"name": "Wooz", "id": 1, "universe_id": null}}
-        #         hash => {"lead_bottle"=>{"name"=>"Wooz", "id"=>1, "universe_id"=>nil}}
-        # Xml =>
-        #         body =>
-        #         <?xml version="1.0" encoding="UTF-8"?>
-        #         <lead-bottle>
-        #           <id type="integer">1</id>
-        #           <name>Wooz</name>
-        #           <universe-id type="integer" nil="true"></universe-id>
-        #         </lead-bottle>
-        #         hash =>
-        #         {"lead-bottle"=>{"name"=>{"__content__"=>"Wooz"}, "universe-id"=>{"type"=>"integer", "nil"=>"true"}, "id"=>{"__content__"=>"1", "type"=>"integer"}}}
-        #         typecast =>
-        #         {"lead_bottle"=>{"name"=>"Wooz", "id"=>1, "universe_id"=>nil}}
-        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::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"}}})
-
-          BottledUniverse.find(1).should == BottledUniverse.new(:universe_id=>nil, :name=>"Wooz", :id=>1)
-        end
-      end
-    end
-
-    describe 'subclasses of sublasses' do
-      it "should configure its host without affecting its superclass" do
-        Glassware.host.should == "http://localhost:3000"
-        BottledUniverse.host.should == "http://localhost:3001"
-      end
-
-      it "should know its resource collection name when it is a subclass of a subclass" do
-        BottledUniverse.resource_collection_name.should == 'bottled_universes'
-      end
-      
-      
-      it "should know how to create a new resource" do
-        uri = mock(Uri)
-        mock_http_response = mock(Net::HTTPResponse)
-        mock_http_response.stub!(:code).and_return('201')
-        mock_http_response.stub!(:content_type).and_return('application/xml')
-        mock_http_response.stub!(:body).and_return("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bottled-universe>\n  <name>Woot</name>\n <id>1</id>\n </bottled-universe>\n")
-        
-        Uri.should_receive(:new).with("http://localhost:3001/bottled_universes.xml", {}).and_return(uri)
-        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::Native::Response.new(mock_http_response))
-        ware = BottledUniverse.create(:name => 'Woot')
-      end
-    end
-
-    describe 'attribute interface' do
-      it "should fail when getter methods for attributes that don't exist are invoked" do
-        universe = Glassware.new(:owner => 'Kai Wren', :guardian => 'Lung Shan')
-        lambda{ universe.ooga }.should raise_error(NoMethodError)
-      end
-
-      it "should provide getter methods for attributes" do
-        universe = Glassware.new(:owner => 'Kai Wren', :guardian => 'Lung Shan')
-        universe.owner.should == 'Kai Wren'
-        universe.guardian.should == 'Lung Shan'
-      end
-
-      it "should respond to getter methods for attributes" do
-        universe = Glassware.new(:owner => 'Kai Wren', :guardian => 'Lung Shan')
-        universe.should respond_to(:owner)
-        universe.should respond_to(:guardian)
-      end
-
-      it "should not respond to getter methods for attributes that don't exist" do
-        universe = Glassware.new(:owner => 'Kai Wren', :guardian => 'Lung Shan')
-        universe.should_not respond_to(:theronic)
-      end
-
-      it "should create a setter method when one is invoked for attributes that don't exist" do
-        universe = Glassware.new(:owner => 'Kai Wren', :guardian => 'Lung Shan')
-        universe.fu_dog = 'Shiriki'
-        universe.attributes[:fu_dog].should == 'Shiriki'
-        universe.fu_dog.should == 'Shiriki'
-      end
-
-      it "should provide setter methods for attributes" do
-        universe = Glassware.new(:owner => 'Kai Wren', :guardian => 'Lung Shan')
-        universe.guardian = 'Effervescent Tiger'
-        universe.attributes[:guardian].should == 'Effervescent Tiger'
-      end
-
-      it "should respond to setter methods for attributes" do
-        universe = Glassware.new(:owner => 'Kai Wren', :guardian => 'Lung Shan')
-        universe.should respond_to(:owner=)
-        universe.should respond_to(:guardian=)
-      end
-
-      it "should not respond to setter methods for attributes that don't exist" do
-        universe = Glassware.new(:owner => 'Kai Wren', :guardian => 'Lung Shan')
-        universe.should_not respond_to(:theronic=)
-      end
-
-      it "should return false when query methods for attributes that don't exist are invoked" do
-        universe = Glassware.new(:owner => 'Kai Wren', :guardian => 'Lung Shan')
-        universe.ooga?.should be_false
-      end
-
-      it "should provide query methods for attributes" do
-        universe = Glassware.new(:owner => 'Kai Wren', :guardian => nil)
-        universe.owner?.should be_true
-        universe.guardian?.should be_false
-      end
-
-      it "should respond to query methods for attributes" do
-        universe = Glassware.new(:owner => 'Kai Wren', :guardian => 'Lung Shan')
-        universe.should respond_to(:owner?)
-        universe.should respond_to(:guardian?)
-      end
-
-      it "should not respond to query methods for attributes that don't exist" do
-        universe = Glassware.new(:owner => 'Kai Wren', :guardian => 'Lung Shan')
-        universe.should_not respond_to(:theronic?)
-      end
-    end
-  end
-end