paul-resourceful 0.3.1 → 0.5.0

data/spec/resourceful/net_http_adapter_spec.rb

@@ -1,96 +0,0 @@
-require 'pathname'
-require Pathname(__FILE__).dirname + '../spec_helper'
-
-require 'resourceful/net_http_adapter'
-
-describe Resourceful::NetHttpAdapter do
-  describe '#make_request (mocked)' do
-    it 'should enable ssl on the connection' do
-      resp = stub('http_response', :code => 200, :header => {}, :body => "hello")
-      conn = stub('http_conn', :request => resp, :finish => nil)
-      Net::HTTP.should_receive(:new).and_return(conn)
-      conn.should_receive(:use_ssl=).with(true).ordered
-      conn.should_receive(:start).ordered
-
-      Resourceful::NetHttpAdapter.make_request(:get, 'https://localhost:3000/get')
-    end
-  end
-end
-
-describe Resourceful::NetHttpAdapter do
-  it_should_behave_like 'simple http server'
-
-
-  describe '#make_request' do
-    before do
-      @response = Resourceful::NetHttpAdapter.make_request(:get, 'http://localhost:3000/get')
-    end
-    
-    describe 'response' do
-      it 'should be an array' do
-        @response.should be_instance_of(Array)
-      end
-
-      it 'should have the numeric response code as the first element' do
-        code = @response[0]
-        code.should be_instance_of(Fixnum)
-        code.should == 200
-      end
-
-      it 'should have the Header as the second element' do
-        header = @response[1]
-        header.should be_instance_of(Resourceful::Header)
-        header['content-type'].should == ['text/plain']
-      end
-
-      it 'should have the body as the third and last element' do
-        body = @response[2]
-        body.should == "Hello, world!"
-      end
-
-    end
-
-  end
-
-  describe '#net_http_request_class' do
-
-    it 'should provide Net::HTTP::Get for a get method' do
-      Resourceful::NetHttpAdapter.send(:net_http_request_class, :get).should == Net::HTTP::Get
-    end
-
-    it 'should provide Net::HTTP::Post for a post method' do
-      Resourceful::NetHttpAdapter.send(:net_http_request_class, :post).should == Net::HTTP::Post
-    end
-
-    it 'should provide Net::HTTP::Put for a put method' do
-      Resourceful::NetHttpAdapter.send(:net_http_request_class, :put).should == Net::HTTP::Put
-    end
-
-    it 'should provide Net::HTTP::Delete for a delete method' do
-      Resourceful::NetHttpAdapter.send(:net_http_request_class, :delete).should == Net::HTTP::Delete
-    end
-
-  end
-
-end
-
-describe Addressable::URI, '#absolute_path monkey patch' do
-
-  it 'should have the path and any query parameters' do
-    uri = Addressable::URI.parse('http://localhost/foo?bar=baz')
-    uri.absolute_path.should == '/foo?bar=baz'
-  end
-
-  it 'should not have a ? if there are no query params' do
-    uri = Addressable::URI.parse('http://localhost/foo')
-    uri.absolute_path.should_not =~ /\?/
-    uri.absolute_path.should == '/foo'
-  end
-
-  it 'should not add the query parameter twice' do
-    uri = Addressable::URI.parse('http://localhost/foo?bar=baz')
-    uri.absolute_path.should == '/foo?bar=baz'
-    uri.absolute_path.should == '/foo?bar=baz'
-  end
-
-end

data/spec/resourceful/options_interpreter_spec.rb

@@ -1,102 +0,0 @@
-require File.dirname(__FILE__) + "/../spec_helper"
-require 'resourceful/options_interpreter'
-
-describe Resourceful::OptionsInterpreter, '#initialize' do
-  it 'should be creatable block' do
-    Resourceful::OptionsInterpreter.new() {}
-  end 
-end 
-
-
-describe Resourceful::OptionsInterpreter, "#option()" do
-  before do
-    @interpreter = Resourceful::OptionsInterpreter.new()
-  end
-  
-  it 'should take option name' do
-    @interpreter.option(:test)
-    @interpreter.supported_options.should include(:test)
-  end 
-
-  it 'should take interpretation block' do
-    @interpreter.option(:test) {"this"}
-    @interpreter.supported_options.should include(:test)
-  end 
-end 
-
-describe Resourceful::OptionsInterpreter, '#interpret(options)' do
-  before do
-    @interpreter = Resourceful::OptionsInterpreter.new()
-    @interpreter.option(:foo)
-  end
-  
-  it 'should return hash like structure of interpreted options' do
-    opts = @interpreter.interpret(:foo => 'bar')
-    
-    opts.should have_key(:foo)
-    opts[:foo].should == 'bar'
-  end 
-  
-  it 'should raise argument error if there is an unsupported option in src hash' do
-    lambda {
-      @interpreter.interpret(:bar => 'baz')
-    }.should raise_error(ArgumentError, "Unrecognized options: bar")
-  end
-
-  it 'should list all unsupported options in the exception' do
-    lambda {
-      @interpreter.interpret(:bar => 'baz', :baz => 'bar')
-    }.should raise_error(ArgumentError, /Unrecognized options: (bar, baz)|(baz, bar)/)
-  end
-
-  it 'should execute pass the options though the appropriate handling block' do
-    @interpreter.option(:foo) {|foo| foo + " hello"}
-    
-    @interpreter.interpret(:foo => 'bar')[:foo].should == 'bar hello'
-  end 
-  
-  it 'should not include options that were not passed in resulting hash' do
-    @interpreter = Resourceful::OptionsInterpreter.new()
-    @interpreter.option(:foo)
-    
-    @interpreter.interpret({}).keys.should_not include(:foo)
-  end 
-
-  it 'should not invoked option value munging block if option is not specified' do 
-    @interpreter = Resourceful::OptionsInterpreter.new()
-    munging_block_executed = false
-    @interpreter.option(:foo) { |a| munging_block_executed = true }
-
-    lambda {
-      @interpreter.interpret({})
-    }.should_not change{munging_block_executed}
-  end
-  
-  it 'should use default if option is not specified' do
-    @interpreter = Resourceful::OptionsInterpreter.new()
-    @interpreter.option(:foo, :default => 'hello')
-
-    opts = @interpreter.interpret({})
-    opts.should have_key(:foo)
-    opts[:foo].should == 'hello'
-  end 
-
-  it 'should use default value if option is specified as nil' do
-    @interpreter = Resourceful::OptionsInterpreter.new()
-    @interpreter.option(:foo, :default => 'hello')
-
-    opts = @interpreter.interpret({:foo => nil})
-    opts.should have_key(:foo)
-    opts[:foo].should == 'hello'
-  end 
-
-  it 'should not use default if option is specified ' do
-    @interpreter = Resourceful::OptionsInterpreter.new()
-    @interpreter.option(:foo, :default => 'hello')
-
-    opts = @interpreter.interpret({:foo => 'bye'})
-    opts.should have_key(:foo)
-    opts[:foo].should == 'bye'
-  end 
-
-end 

data/spec/resourceful/request_spec.rb

@@ -1,186 +0,0 @@
-require 'pathname'
-require Pathname(__FILE__).dirname + '../spec_helper'
-require 'rubygems'
-require 'addressable/uri'
-
-describe Resourceful::Request do
-  before do
-    @uri = Addressable::URI.parse('http://www.example.com')
-    @resource = mock('resource', :logger => Resourceful::BitBucketLogger.new)
-    @resource.stub!(:uri).and_return(@uri)
-
-    @request = Resourceful::Request.new(:get, @resource)
-
-    @cachemgr = mock('cache_mgr')
-    @cachemgr.stub!(:lookup).and_return(nil)
-    @cachemgr.stub!(:store)
-    @resource.stub!(:accessor).and_return(mock('accessor', :cache_manager => @cachemgr, :logger => Resourceful::BitBucketLogger.new))
-  end
-
-  describe 'init' do
-
-    it 'should be instantiatable' do
-      @request.should be_instance_of(Resourceful::Request)
-    end
-
-    it 'should take an http method' do
-      @request.method.should == :get
-    end
-
-    it 'should take a resource' do
-      @request.resource.should == @resource
-    end
-
-    it 'should take an optional body' do
-      req = Resourceful::Request.new(:get, @resource)
-      req.body.should be_nil
-
-      req = Resourceful::Request.new(:post, @resource, 'Hello from post!')
-      req.body.should == 'Hello from post!'
-    end
-
-    it 'should have a request_time' do
-      @request.should respond_to(:request_time)
-    end
-
-  end
-
-  describe '#response' do
-    before do
-      @net_http_adapter_response = mock('net_http_adapter_response')
-      Resourceful::NetHttpAdapter.stub!(:make_request).and_return(@net_http_adapter_response)
-
-      @response = mock('response', :code => 200, :authoritative= => true, :was_unsuccessful? => false, :request_time= => nil)
-      Resourceful::Response.stub!(:new).and_return(@response)
-    end
-
-    it 'should be a method' do
-      @request.should respond_to(:response)
-    end
-
-    it 'should return the Response object' do
-      @request.response.should == @response
-    end
-
-    it 'should set the request_time to now' do
-      now = Time.now
-      Time.stub!(:now).and_return(now)
-
-      @request.response
-      @request.request_time.should == now
-    end
-
-    it 'should set the response\'s request time' do
-      now = Time.now
-      Time.stub!(:now).and_return(now)
-
-      @response.should_receive(:request_time=).with(now)
-      @request.response
-    end
-  end
-
-  describe '#should_be_redirected?' do
-    before do
-      @net_http_adapter_response = mock('net_http_adapter_response')
-      Resourceful::NetHttpAdapter.stub!(:make_request).and_return(@net_http_adapter_response)
-
-      @response = mock('response', :code => 200, :authoritative= => true, :was_unsuccessful? => false, :request_time= => nil)
-      Resourceful::Response.stub!(:new).and_return(@response)
-    end
-
-    describe 'with no callback set' do
-      before do
-        @callback = nil
-        @resource.stub!(:on_redirect).and_return(@callback)
-      end
-
-      it 'should be true for GET' do
-        request = Resourceful::Request.new(:get, @resource, @post_data)
-
-        request.should_be_redirected?.should be_true
-      end
-
-      it 'should be false for POST, etc' do
-        request = Resourceful::Request.new(:post, @resource, @post_data)
-
-        request.should_be_redirected?.should be_false
-      end
-
-    end
-
-    it 'should be true when callback returns true' do
-      @callback = lambda { true }
-      @resource.stub!(:on_redirect).and_return(@callback)
-      request = Resourceful::Request.new(:get, @resource, @post_data)
-
-      request.should_be_redirected?.should be_true
-    end
-
-    it 'should be false when callback returns false' do
-      @callback = lambda { false }
-      @resource.stub!(:on_redirect).and_return(@callback)
-      request = Resourceful::Request.new(:get, @resource, @post_data)
-
-      request.should_be_redirected?.should be_false
-    end
-
-  end 
-
-  describe "content coding" do 
-    it "should set Accept-Encoding automatically" do
-      @request.header['Accept-Encoding'].should == 'gzip, identity'
-    end
-  end
-
-  describe '#set_validation_headers' do
-    before do
-      @cached_response = mock('cached_response')
-
-      @cached_response_header = mock('header', :[] => nil, :has_key? => false)
-      @cached_response.stub!(:header).and_return(@cached_response_header)
-
-      @cachemgr.stub!(:lookup).and_return(@cached_response)
-    end
-
-    it 'should have an #set_validation_headers method' do
-      @request.should respond_to(:set_validation_headers)
-    end
-
-    it 'should set If-None-Match to the cached response\'s ETag' do
-      @cached_response_header.should_receive(:[]).with('ETag').and_return('some etag')
-      @cached_response_header.should_receive(:has_key?).with('ETag').and_return(true)
-      @request.set_validation_headers(@cached_response)
-
-      @request.header['If-None-Match'].should == 'some etag'
-    end
-
-    it 'should not set If-None-Match if the cached response does not have an ETag' do
-      @request.set_validation_headers(@cached_response)
-      @request.header.should_not have_key('If-None-Match')
-    end
-
-    it 'should set If-Modified-Since to the cached response\'s Last-Modified' do
-      @cached_response_header.should_receive(:[]).with('Last-Modified').and_return('some date')
-      @cached_response_header.should_receive(:has_key?).with('Last-Modified').and_return(true)
-      @request.set_validation_headers(@cached_response)
-
-      @request.header['If-Modified-Since'].should == 'some date'
-    end
-
-    it 'should not set If-Modified-Since if the cached response does not have Last-Modified' do
-      @request.set_validation_headers(@cached_response)
-      @request.header.should_not have_key('If-Modified-Since')
-    end
-
-    it 'should add "Cache-Control: max-age=0" to the request when revalidating a response that has "Cache-Control: must-revalidate" set' do
-      @cached_response_header.should_receive(:[]).with('Cache-Control').and_return(['must-revalidate'])
-      @cached_response_header.should_receive(:has_key?).with('Cache-Control').and_return(true)
-      @request.set_validation_headers(@cached_response)
-
-      @request.header['Cache-Control'].should include('max-age=0')
-    end
-
-  end
-
-end
-

data/spec/resourceful/resource_spec.rb

@@ -1,600 +0,0 @@
-require 'pathname'
-require Pathname(__FILE__).dirname + '../spec_helper'
-
-require 'resourceful/resource'
-
-describe Resourceful::Resource do
-  before do
-    @auth_manager = mock('auth_manager', :add_credentials => nil)
-    @cache_manager = mock('cache_manager', :lookup => nil, :store => nil, :invalidate => nil)
-    @logger = mock('logger', :debug => nil, :info => nil)
-    @accessor = mock('accessor', :auth_manager => @auth_manager, 
-                                 :cache_manager => @cache_manager, 
-                                 :logger => @logger)
-
-    @uri      = 'http://www.example.com/'
-    @resource = Resourceful::Resource.new(@accessor, @uri)
-
-    @response = mock('response', :code => 200, 
-                                 :is_redirect? => false, 
-                                 :is_not_authorized? => false, 
-                                 :is_success? => true,
-                                 :is_not_modified? => false)
-
-    @request = mock('request', :response => @response, :should_be_redirected? => true, :uri => @uri)
-    Resourceful::Request.stub!(:new).and_return(@request)
-  end
-
-  describe 'init' do
-    it 'should be instantiatable' do
-      @resource.should be_instance_of(Resourceful::Resource)
-    end
-
-    it 'should take an http_accessor' do
-      @resource.accessor.should == @accessor
-    end
-
-    it 'should take a uri' do
-      @resource.uri.should == @uri
-    end
-
-    it 'should take some default_options' do
-      r = Resourceful::Resource.new(@accessor, @uri, :foo => :bar)
-      r.default_options.should == {:foo => :bar}
-    end
-
-    it 'should default to an empty hash for options' do
-      @resource.default_options.should == {}
-    end
-  end
-
-  describe '#effective_uri' do
-
-    it 'should be the latest uri' do
-      @resource.effective_uri.should == @uri
-    end
-
-    it 'should be aliased as #uri' do
-      @resource.uri.should == @resource.effective_uri
-    end
-
-  end
-
-  describe '#do_read_request' do
-
-    def make_request
-      @resource.do_read_request(:some_method)
-    end
-
-    it 'should make a new request object from the method' do
-      Resourceful::Request.should_receive(:new).with(:some_method, @resource, nil, {}).and_return(@request)
-      make_request
-    end
-
-    it 'should set the header of the request from the header arg' do
-      Resourceful::Request.should_receive(:new).with(:some_method, @resource, nil, :foo => :bar).and_return(@request)
-      @resource.do_read_request(:some_method, :foo => :bar)
-    end
-
-    describe 'default options' do
-      before do
-        @resource.default_options = {:foo => :bar}
-      end
-
-      it 'should merge the header with the default options' do
-        Resourceful::Request.should_receive(:new).with(anything, anything, anything, :foo => :bar).and_return(@request)
-        make_request
-      end
-
-      it 'should override any default header with the request header' do
-        Resourceful::Request.should_receive(:new).with(anything, anything, anything, :foo => :baz).and_return(@request)
-        @resource.do_read_request(:some_method, :foo => :baz)
-      end
-    end
-
-    describe 'non-success responses' do
-      before do
-        @uri      = 'http://www.example.com/code/404'
-        @resource = Resourceful::Resource.new(@accessor, @uri)
-
-        @redirected_uri = 'http://www.example.com/get'
-        @redirect_response = mock('redirect_response',
-                                  :header                 => {'Location' => [@redirected_uri]},
-                                  :is_redirect?           => false,
-                                  :is_success?            => false,
-                                  :is_not_authorized?     => false,
-                                  :is_not_modified?       => false,
-                                  :code                   => 404)
-        
-        @request.stub!(:response).and_return(@redirect_response, @response)
-        @request.stub!(:method).and_return(:get)
-        @request.stub!(:uri).and_return('http://www.example.com/code/404')
-      end
-
-      it 'should raise UnsuccessfulHttpRequestError' do
-        lambda {
-          @resource.do_read_request(:get)
-        }.should raise_error(Resourceful::UnsuccessfulHttpRequestError)
-      end 
-
-      it 'should give a reasonable error message' do
-        lambda {
-          @resource.do_read_request(:get)
-        }.should raise_error("get request to <http://www.example.com/code/404> failed with code 404")
-      end
-    end 
-
-    describe 'with redirection' do
-      before do
-        @uri      = 'http://www.example.com/redirect/301?http://www.example.com/get'
-        @resource = Resourceful::Resource.new(@accessor, @uri)
-
-        @redirected_uri = 'http://www.example.com/get'
-        @redirect_response = mock('redirect_response',
-                                  :header                 => {'Location' => [@redirected_uri]},
-                                  :is_redirect?           => true,
-                                  :is_permanent_redirect? => true,
-                                  :is_not_modified?       => false)
-
-        @request.stub!(:response).and_return(@redirect_response, @response)
-
-      end
-
-      it 'should check if the response was a redirect' do
-        @redirect_response.should_receive(:is_redirect?).and_return(true)
-        make_request
-      end
-
-      it 'should check if the request should be redirected' do
-        @request.should_receive(:should_be_redirected?).and_return(true)
-        make_request
-      end
-
-      describe 'permanent redirect' do
-        before do
-          @redirect_response.stub!(:is_permanent_redirect?).and_return(true)
-        end
-
-        it 'should check if the response was a permanent redirect' do
-          @redirect_response.should_receive(:is_permanent_redirect?).and_return(true)
-          make_request
-        end
-
-        it 'should add the new location as the effective uri' do
-          make_request
-          @resource.effective_uri.should == @redirected_uri
-        end
-
-        it 'should remake the request with the new uri' do
-          Resourceful::Request.should_receive(:new).twice.and_return(@request)
-          @request.should_receive(:response).twice.and_return(@redirect_response, @response)
-          make_request
-        end
-
-      end
-
-      describe 'temporary redirect' do
-        before do
-          @redirect_response.stub!(:is_permanent_redirect?).and_return(false)
-        end
-
-        it 'should check if the response was not a permanent redirect' do
-          @redirect_response.should_receive(:is_permanent_redirect?).and_return(false)
-          make_request
-        end
-
-        it 'should not add the new location as the effective uri' do
-          make_request
-          @resource.effective_uri.should == @uri
-        end
-        
-        it 'should make a new resource from the new location' do
-          new_resource = mock('resource', :do_read_request => @response, :uri => @uri)
-          Resourceful::Resource.should_receive(:new).with(@accessor, @redirected_uri).and_return(new_resource)
-          make_request
-        end
-
-      end
-
-    end # read with redirection
-
-    describe 'with authorization' do
-      before do
-        @authmgr = mock('auth_manager')
-        @authmgr.stub!(:add_credentials)
-        @authmgr.stub!(:associate_auth_info).and_return(true)
-
-        @accessor.stub!(:auth_manager).and_return(@authmgr)
-      end
-
-      it 'should attempt to add credentials to the request' do
-        @authmgr.should_receive(:add_credentials).with(@request)
-        make_request
-      end
-
-      it 'should check if the response was not authorized' do
-        @response.should_receive(:is_not_authorized?).and_return(false)
-        make_request
-      end
-
-      it 'should associate the auth info in the response if it was not authorized' do
-        @authmgr.should_receive(:associate_auth_info).with(@response).and_return(true)
-        @response.stub!(:is_not_authorized?).and_return(true)
-        make_request
-      end
-
-      it 'should re-make the request only once if it was not authorized the first time' do
-        Resourceful::Request.should_receive(:new).with(:some_method, @resource, nil, {}).twice.and_return(@request)
-        @response.stub!(:is_not_authorized?).and_return(true)
-        make_request
-      end
-
-    end
-
-    describe 'with caching' do
-      before do
-        @cached_response = mock('cached response', :is_redirect? => false,
-                                                   :is_not_authorized? => false,
-                                                   :is_success? => true,
-                                                   :stale? => false)
-        @cache_manager.stub!(:lookup).and_return(@cached_response)
-      end
-
-      it 'should lookup the request in the cache' do
-        @cache_manager.should_receive(:lookup).with(@request)
-        make_request
-      end
-
-      it 'should check if the cached response is stale' do
-        @cached_response.should_receive(:stale?).and_return(false)
-        make_request
-      end
-
-      describe 'in cache' do
-
-      end
-
-      describe 'in cache but stale' do
-
-      end
-
-      describe 'not in cache' do
-
-      end
-
-    end
-
-  end
-
-  describe '#do_write_request' do
-
-    def make_request
-      @resource.do_write_request(:some_method, "data")
-    end
-
-    it 'should make a new request object from the method' do
-      Resourceful::Request.should_receive(:new).with(:some_method, @resource, "data", anything).and_return(@request)
-      @resource.do_write_request(:some_method, "data")
-    end
-
-    describe 'default options' do
-      before do
-        @resource.default_options = {:foo => :bar}
-      end
-
-      it 'should merge the header with the default options' do
-        Resourceful::Request.should_receive(:new).with(anything, anything, anything, :foo => :bar).and_return(@request)
-        make_request
-      end
-
-      it 'should override any default header with the request header' do
-        Resourceful::Request.should_receive(:new).with(anything, anything, anything, :foo => :baz).and_return(@request)
-        @resource.do_write_request(:some_method, "data", :foo => :baz)
-      end
-    end
-
-    describe 'non-success responses' do
-      before do
-        @uri      = 'http://www.example.com/code/404'
-        @resource = Resourceful::Resource.new(@accessor, @uri)
-
-        @redirected_uri = 'http://www.example.com/get'
-        @response = mock('response',
-                         :header                 => {'Location' => [@redirected_uri]},
-                         :is_redirect?           => false,
-                         :is_success?            => false,
-                         :is_not_authorized?     => false,
-                         :code                   => 404)
-        
-        @request.stub!(:response).and_return(@response)
-        @request.stub!(:method).and_return(:post)
-        @request.stub!(:uri).and_return('http://www.example.com/code/404')
-      end
-
-      it 'should raise UnsuccessfulHttpRequestError' do
-        lambda {
-          @resource.do_write_request(:post, "data")
-        }.should raise_error(Resourceful::UnsuccessfulHttpRequestError)
-      end 
-
-      it 'should give a reasonable error message' do
-        lambda {
-          @resource.do_write_request(:post, "data")
-        }.should raise_error("post request to <http://www.example.com/code/404> failed with code 404")
-      end
-    end 
-
-    describe 'with redirection' do
-      before do
-        @uri      = 'http://www.example.com/redirect/301?http://www.example.com/get'
-        @resource = Resourceful::Resource.new(@accessor, @uri)
-
-        @redirected_uri = 'http://www.example.com/get'
-        @redirect_response = mock('redirect_response',
-                                  :header                 => {'Location' => [@redirected_uri]},
-                                  :is_redirect?           => true,
-                                  :is_permanent_redirect? => true)
-
-        @request.stub!(:response).and_return(@redirect_response, @response)
-
-      end
-
-      it 'should check if the response was a redirect' do
-        @redirect_response.should_receive(:is_redirect?).and_return(true)
-        make_request
-      end
-
-      it 'should check if the request should be redirected' do
-        @request.should_receive(:should_be_redirected?).and_return(true)
-        make_request
-      end
-
-      describe 'permanent redirect' do
-        before do
-          @redirect_response.stub!(:is_permanent_redirect?).and_return(true)
-        end
-
-        it 'should check if the response was a permanent redirect' do
-          @redirect_response.should_receive(:is_permanent_redirect?).and_return(true)
-          make_request
-        end
-
-        it 'should add the new location as the effective uri' do
-          make_request
-          @resource.effective_uri.should == @redirected_uri
-        end
-
-        it 'should remake the request with the new uri' do
-          Resourceful::Request.should_receive(:new).twice.and_return(@request)
-          @request.should_receive(:response).twice.and_return(@redirect_response, @response)
-          make_request
-        end
-
-      end
-
-      describe 'temporary redirect' do
-        before do
-          @redirect_response.stub!(:is_permanent_redirect?).and_return(false)
-            @redirect_response.stub!(:code).and_return(302)
-        end
-
-        it 'should check if the response was not a permanent redirect' do
-          @redirect_response.should_receive(:is_permanent_redirect?).and_return(false)
-          make_request
-        end
-
-        it 'should not add the new location as the effective uri' do
-          make_request
-          @resource.effective_uri.should == @uri
-        end
-        
-        it 'should make a new resource from the new location' do
-          new_resource = mock('resource', :do_write_request => @response)
-          Resourceful::Resource.should_receive(:new).with(@accessor, @redirected_uri).and_return(new_resource)
-          make_request
-        end
-
-        describe '302 Found' do
-          before do
-            @new_resource = mock('resource')
-            Resourceful::Resource.should_receive(:new).with(@accessor, @redirected_uri).and_return(@new_resource)
-            @redirect_response.stub!(:code).and_return(303)
-          end
-
-          it 'should redirect to the new location with a GET request, regardless of the original method' do
-            @new_resource.should_receive(:do_read_request).with(:get, {}).and_return(@response)
-            make_request
-          end
-        end
-
-      end
-
-    end # write with redirection
-    
-    describe 'with authorization' do
-      before do
-        @authmgr = mock('auth_manager')
-        @authmgr.stub!(:add_credentials)
-        @authmgr.stub!(:associate_auth_info).and_return(true)
-
-        @accessor.stub!(:auth_manager).and_return(@authmgr)
-      end
-
-      it 'should attempt to add credentials to the request' do
-        @authmgr.should_receive(:add_credentials).with(@request)
-        make_request
-      end
-
-      it 'should check if the response was not authorized' do
-        @response.should_receive(:is_not_authorized?).and_return(false)
-        make_request
-      end
-
-      it 'should associate the auth info in the response if it was not authorized' do
-        @authmgr.should_receive(:associate_auth_info).with(@response).and_return(true)
-        @response.stub!(:is_not_authorized?).and_return(true)
-        make_request
-      end
-
-      it 'should re-make the request only once if it was not authorized the first time' do
-        Resourceful::Request.should_receive(:new).with(:some_method, @resource, "data", {}).twice.and_return(@request)
-        @response.stub!(:is_not_authorized?).and_return(true)
-        make_request
-      end
-    end
-
-  end
-
-  describe 'callback registration' do
-    before do
-      @callback = mock('callback')
-      @callback.stub!(:call).and_return(true)
-
-      @resource.on_redirect { @callback.call }
-    end
-
-    it 'should store the callback when called with a block' do
-      @resource.on_redirect { true }
-
-      callback = @resource.instance_variable_get(:@on_redirect)
-      callback.should be_kind_of(Proc)
-    end
-
-    it 'should return the callback when called without a block' do
-      callback = lambda { "foo" }
-      @resource.on_redirect(&callback)
-      @resource.on_redirect.should == callback
-    end
-
-  end
-
-  describe '#get' do
-
-    it 'should be a method' do
-      @resource.should respond_to(:get)
-    end
-
-    it 'should pass :get to the #do_read_request method' do
-      @resource.should_receive(:do_read_request).with(:get, {}).and_return(@response)
-      @resource.get
-    end
-
-    it 'should return the response of making the request' do
-      @resource.get.should == @response
-    end
-
-  end
-
-  describe "#delete" do
-
-    it 'should be a method' do
-      @resource.should respond_to(:delete)
-    end
-
-    it 'should return the response of making the request' do
-      @resource.delete.should == @response
-    end
-
-  end
-
-  describe "#post(body_data, :content_type => content-type)" do
-    before do
-      @resource = Resourceful::Resource.new(@accessor, 'http://foo.invalid/')
-      @response = mock('response', :is_redirect? => false, :is_success? => true, :is_not_authorized? => false, :code => 200)
-      @request = mock('request', :response => @response)
-      Resourceful::Request.stub!(:new).and_return(@request)
-    end
-    
-    it "should get the response from the request" do 
-      @request.should_receive(:response).and_return(@response)
-
-      @resource.post("a body", :content_type => 'text/plain')
-    end
-
-    it 'should put the content type in the header' do
-      Resourceful::Request.should_receive(:new).
-        with(anything,
-             anything, 
-             anything, 
-             hash_including(:content_type =>'text/plain')).
-        and_return(@request)
-
-      @resource.post("a body", :content_type => 'text/plain') 
-    end 
-
-    it 'should create a post request' do
-      Resourceful::Request.should_receive(:new).
-        with(:post, anything, anything, anything).
-        and_return(@request)
-
-      @resource.post("a body", :content_type => 'text/plain') 
-    end 
-
-    it 'should pass body to the request object' do
-      Resourceful::Request.should_receive(:new).
-        with(anything, anything, "a body", anything).
-        and_return(@request)
-
-      @resource.post("a body", :content_type => 'text/plain') 
-    end 
-
-    it 'should pass self to the request object' do
-      Resourceful::Request.should_receive(:new).
-        with(anything, @resource, anything, anything).
-        and_return(@request)
-
-      @resource.post("a body", :content_type => 'text/plain') 
-    end 
-  end
-
-  describe "#put(body_data, :content_type => content_type)" do
-    before do
-      @resource = Resourceful::Resource.new(@accessor, 'http://foo.invalid/')
-      @response = mock('response', :is_redirect? => false, :is_success? => true, :is_not_authorized? => false, :code => 200)
-      @request = mock('request', :response => @response)
-      Resourceful::Request.stub!(:new).and_return(@request)
-    end
-    
-    it "should get the response from the request" do 
-      @request.should_receive(:response).and_return(@response)
-
-      @resource.put("a body", :content_type => 'text/plain')
-    end
-
-    it 'should put the content type in the header' do
-      Resourceful::Request.should_receive(:new).
-        with(anything,
-             anything, 
-             anything, 
-             hash_including(:content_type =>'text/plain')).
-        and_return(@request)
-
-      @resource.put("a body", :content_type => 'text/plain') 
-    end 
-
-    it 'should create a put request' do
-      Resourceful::Request.should_receive(:new).
-        with(:put, anything, anything, anything).
-        and_return(@request)
-
-      @resource.put("a body", :content_type => 'text/plain') 
-    end 
-
-    it 'should pass body to the request object' do
-      Resourceful::Request.should_receive(:new).
-        with(anything, anything, "a body", anything).
-        and_return(@request)
-
-      @resource.put("a body", :content_type => 'text/plain') 
-    end 
-
-    it 'should pass self to the request object' do
-      Resourceful::Request.should_receive(:new).
-        with(anything, @resource, anything, anything).
-        and_return(@request)
-
-      @resource.put("a body", :content_type => 'text/plain') 
-    end 
-  end
-
-end