wrest 0.0.8-java → 0.0.9-java

data/spec/functional/sample_rails_app/vendor/plugins/resource_full/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

data/spec/{spec_helper.rb → unit/spec_helper.rb}

@@ -1,7 +1,7 @@
-require File.expand_path(File.dirname(__FILE__) + "/../lib/wrest")
+require File.expand_path(File.dirname(__FILE__) + "/../../lib/wrest")
 require 'spec'
 
-["/custom_matchers/**/*.rb"].each{|directory|
+['/../custom_matchers/**/*.rb'].each{|directory|
   Dir["#{File.expand_path(File.dirname(__FILE__) + directory)}"].each { |file|
     require file
   }

data/spec/unit/wrest/components/attributes_container/alias_accessors_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+module Wrest::Components
+  describe AttributesContainer::AliasAccessors do
+    before :each do
+      @Demon = Class.new
+      @Demon.class_eval do
+        include Wrest::Components::AttributesContainer
+      end
+    end
+
+    it "should provide a macro to enable aliasing accessors" do
+      lambda{ @Demon.class_eval{ alias_accessors :shiriki => :chambala } }.should_not raise_error(NoMethodError)
+    end
+
+    describe 'aliasing' do
+      before :each do
+        @Demon.class_eval{ alias_accessors :sex => :gender, :age => :maturity }
+      end
+
+      it "should provide an accessor methods when we alias to an attribute" do
+        demon = @Demon.new
+        demon.should respond_to(:gender)
+        demon.should respond_to(:gender=)
+        demon.should respond_to(:gender?)
+        demon.should respond_to(:maturity)
+        demon.should respond_to(:maturity=)
+        demon.should respond_to(:maturity?)
+      end
+
+      it "should ensure that the aliased getter method delegates to the actual getter" do
+        demon = @Demon.new :sex => 'male'
+        demon.gender.should == 'male'
+      end
+
+      it "should ensure that the aliased setter method delegates to the actual getter" do
+        demon = @Demon.new
+        demon.should_receive(:sex=).with('male')
+        demon.gender = 'male'
+      end
+
+      it "should ensure that the aliased query method delegates to the actual queryier" do
+        demon = @Demon.new :age => '1000'
+        demon.gender?.should be_false
+        demon.maturity?.should be_true
+      end
+    end
+  end
+end

data/spec/{wrest → unit/wrest}/components/attributes_container/typecaster_spec.rb

@@ -5,8 +5,8 @@ module Wrest::Components
     before :each do
       @Demon = Class.new
       @Demon.class_eval do
-        include AttributesContainer
-        include AttributesContainer::Typecaster
+        include Wrest::Components::AttributesContainer
+        include Wrest::Components::AttributesContainer::Typecaster
       end
     end
 
@@ -16,10 +16,30 @@ module Wrest::Components
       kai_wren.age.should == 1
     end
 
-    it "should not apply a lambda to the value of a given key if it is not a string" do
-      @Demon.class_eval{ typecast :age => lambda{|id_string| id_string.to_i} }
-      kai_wren = @Demon.new('age' => :ooga)
-      kai_wren.age.should == :ooga
+    describe "where the value is not a typecastable type" do
+      it "string should not typecast" do
+        @Demon.class_eval{ typecast :age => lambda{|id_string| id_string.to_i} }
+        kai_wren = @Demon.new('age' => :ooga)
+        kai_wren.age.should == :ooga
+      end
+
+      it "hash should not typecast" do
+        class TestUser
+          include Wrest::Components::AttributesContainer
+        end
+
+        @Demon.class_eval{ typecast :user => lambda{|user| TestUser.new(user)}}
+
+        kai_wren = @Demon.new('user' => {'foo' => 'bar'})
+        kai_wren.user.class.should == TestUser
+        kai_wren.user.foo.should == 'bar'
+      end
+
+      it "array should not typecast" do
+        @Demon.class_eval{ typecast :addresses => lambda{|addresses| addresses.first} }
+        kai_wren = @Demon.new('addresses' => ['foo', 'bar'])
+        kai_wren.addresses.should == 'foo'
+      end
     end
 
     it "should leave nils unchanged" do
@@ -38,8 +58,8 @@ module Wrest::Components
       before :each do
         @Sidhe = Class.new
         @Sidhe.class_eval do
-          include AttributesContainer
-          include AttributesContainer::Typecaster
+          include Wrest::Components::AttributesContainer
+          include Wrest::Components::AttributesContainer::Typecaster
 
           typecast :age => as_integer
         end

data/spec/{wrest → unit/wrest}/components/attributes_container_spec.rb

@@ -12,10 +12,34 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 module Wrest::Components
   describe AttributesContainer do
     class HumanBeing
-      include AttributesContainer
+      include Wrest::Components::AttributesContainer
       always_has :id
     end
 
+    describe "typecasting" do
+      before(:each) do
+        @Demon = Class.new
+
+        @Demon.class_eval do
+          include Wrest::Components::AttributesContainer
+        end
+      end
+
+      it "should delegate to AttributesContainer::Typecaster#typecast to actually do the typecasting" do
+        @Demon.class_eval do
+          typecast :foo => lambda{|value| value.to_i}
+        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
+        end
+        @Demon.new(:foo => '1').foo.should == 1
+      end
+    end
+
     it "should allow instantiation with no attributes" do
       lambda{ HumanBeing.new }.should_not raise_error
     end
@@ -26,39 +50,41 @@ module Wrest::Components
           @Demon = Class.new
         end
 
+        # Methods are string in 1.8 and symbols in 1.9. We'll use to_sym to
+        # allow us to build on both.
         it "should define attribute getters at the class level" do
           kai_wren = @Demon.new
-          kai_wren.methods.should_not include('trainer')
+          kai_wren.methods.map(&:to_sym).should_not include(:trainer)
 
           @Demon.class_eval{
-            include AttributesContainer
+            include Wrest::Components::AttributesContainer
             always_has :trainer
           }
 
-          kai_wren.methods.should include('trainer')
+          kai_wren.methods.map(&:to_sym).should include(:trainer)
         end
 
         it "should define attribute setters at the class level" do
           kai_wren = @Demon.new
-          kai_wren.methods.should_not include('trainer=')
+          kai_wren.methods.map(&:to_sym).should_not include(:trainer=)
 
           @Demon.class_eval{
-            include AttributesContainer
+            include Wrest::Components::AttributesContainer
             always_has :trainer
           }
 
-          kai_wren.methods.should include('trainer=')
+          kai_wren.methods.map(&:to_sym).should include(:trainer=)
         end
 
         it "should define attribute query methods at the class level" do
           kai_wren = @Demon.new
-          kai_wren.methods.should_not include('trainer?')
+          kai_wren.methods.map(&:to_sym).should_not include(:trainer?)
 
           @Demon.class_eval{
-            include AttributesContainer
+            include Wrest::Components::AttributesContainer
             always_has :trainer
           }
-          kai_wren.methods.should include('trainer?')
+          kai_wren.methods.map(&:to_sym).should include(:trainer?)
         end
       end
 
@@ -66,7 +92,7 @@ module Wrest::Components
         before :each do
           @Demon = Class.new
           @Demon.class_eval{
-            include AttributesContainer
+            include Wrest::Components::AttributesContainer
             always_has :trainer
 
             def method_missing(method_name, *args)
@@ -155,14 +181,15 @@ module Wrest::Components
         @li_piao.should_not respond_to(:god=)
       end
 
-      it "should fail when query methods for attributes that don't exist are invoked" do
-        lambda{ @li_piao.ooga? }.should raise_error(NoMethodError)
+      it "should return false when query methods for attributes that don't exist are invoked" do
+        @li_piao.ooga?.should be_false
       end
 
       it "should provide query methods for attributes" do
         li_piao = HumanBeing.new( :profession => 'Natural Magician', :enhanced_by => nil)
         li_piao.profession?.should be_true
         li_piao.enhanced_by?.should be_false
+        li_piao.gender?.should be_false
       end
 
       it "should respond to query methods for attributes" do
@@ -179,14 +206,14 @@ module Wrest::Components
         @li_piao.id = 6
         @li_piao.id.should == 6
       end
-      
+
       it "should provide getter and query methods to instance which has corresponding attribute" do
         zotoh_zhaan = HumanBeing.new(:species => "Delvian")
         zotoh_zhaan.species.should == "Delvian"
         zotoh_zhaan.species?.should be_true
         zotoh_zhaan.species = "Human"
         lambda{@li_piao.species}.should raise_error(NoMethodError)
-        lambda{@li_piao.species?}.should raise_error(NoMethodError)
+        @li_piao.species?.should be_false
         @li_piao.should_not respond_to(:species=)
         @li_piao.methods.grep(/:species=/).should be_empty
       end

data/spec/{wrest → unit/wrest}/components/mutators/base_spec.rb

@@ -12,7 +12,7 @@ require File.dirname(__FILE__) + '/../../../spec_helper'
 module Wrest::Components
   describe Mutators::Base do
     it "should raise an exception if mutate is invoked without do_mutate being implemented in a subclass" do
-      lambda{ Class.new(Mutators::Base).new.mutate([]) }.should raise_error(Wrest::Exceptions::MethodNotOverriddenException)
+      lambda{ Class.new(Mutators::Base).new.mutate([]) }.should raise_error(Wrest::Exceptions::MethodNotOverridden)
     end
 
     it "should ensure that the next mutator is invoked for a subclass" do

data/spec/{wrest → unit/wrest}/components/translators_spec.rb

@@ -12,7 +12,7 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 module Wrest::Components
   describe Translators do
     it "should know how to raise an exception if the mime type doesn't exist" do
-      lambda{ Translators.lookup('weird/unknown')}.should raise_error(Wrest::Exceptions::UnsupportedContentTypeException)
+      lambda{ Translators.lookup('weird/unknown')}.should raise_error(Wrest::Exceptions::UnsupportedContentType)
     end
   end
 end

data/spec/{wrest → unit/wrest}/core_ext/string/conversions_spec.rb

@@ -22,4 +22,18 @@ describe String, 'conversions' do
     uri.username.should == 'ooga'
     uri.password.should == 'booga'
   end
+  
+  it "should strip leading spaces from a uri before building it" do
+    ' http://localhost:3000'.to_uri.should == Wrest::Uri.new('http://localhost:3000')
+  end
+  
+  it "should strip trailing spaces from a uri before building it" do
+    'http://localhost:3000  '.to_uri.should == Wrest::Uri.new('http://localhost:3000')
+  end
+  
+  it "should levae the original string  unchanged after building a uri from it" do
+    url = ' http://localhost:3000  '
+    url.to_uri.should == Wrest::Uri.new('http://localhost:3000')
+    url.should == ' http://localhost:3000  '
+  end
 end

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

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Wrest::Http::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::Http::Get.new(redirect_uri)
+    final_mock_response = mock(Wrest::Http::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)
+    
+    response = Wrest::Http::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/http/request_spec.rb

@@ -0,0 +1,70 @@
+# 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::Http::Request do
+  it "should convert all symbols in header keys to strings" do
+    Wrest::Http::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::Http::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
+  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
+  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
+  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)
+    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)
+    
+    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::Http::Redirection.new(raw_response)
+    
+    mock_connection.should_receive(:request).and_return(raw_response)
+    
+    Wrest::Http::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::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
+end

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

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