resourceful 0.2

data/spec/resourceful/net_http_adapter_spec.rb

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

data/spec/resourceful/options_interpreter_spec.rb

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

@@ -0,0 +1,261 @@
+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')
+    @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))
+  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)
+      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 = mock('now')
+      Time.stub!(:now).and_return(now)
+
+      @request.response
+      @request.request_time.should == now
+    end
+
+    describe 'Caching' do
+      before do
+        @cached_response = mock('cached_response', :body => "", :authoritative= => true)
+        @cached_response.stub!(:stale?).and_return(false)
+
+        @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 lookup the request in the cache' do
+        @cachemgr.should_receive(:lookup).with(@request)
+        @request.response
+      end
+
+      it 'should check if the cached response is stale' do
+        @cached_response.should_receive(:stale?).and_return(false)
+        @request.response
+      end
+
+      describe 'cached' do
+
+        it 'should return the cached response if it was found and not stale' do
+          @cached_response.stale?.should_not be_true
+          @request.response.should == @cached_response
+        end
+
+      end
+
+      describe 'cached but stale' do
+        before do
+          @cached_response.stub!(:stale?).and_return(true)
+        end
+
+        it 'should add the validation headers from the cached_response to it\'s header' do
+          @request.should_receive(:set_validation_headers).with(@cached_response)
+
+          @request.response
+        end
+
+        it 'should #get the uri from the NetHttpAdapter' do
+          Resourceful::NetHttpAdapter.should_receive(:make_request).
+            with(:get, @uri, nil, anything).and_return(@net_http_adapter_response)
+          @request.response
+        end
+
+        it 'should create a Resourceful::Response object from the NetHttpAdapter response' do
+          Resourceful::Response.should_receive(:new).with(@request.uri, @net_http_adapter_response).and_return(@response)
+          @request.response
+        end
+
+        it 'should merge the response\'s headers with the cached response\'s if the response was a 304' do
+          @response_header = mock('header')
+          @response.stub!(:header).and_return(@response_header)
+          @response.stub!(:code).and_return(304)
+          @cached_response_header.should_receive(:merge).with(@response_header)
+          @request.response
+        end
+
+        it 'should store the response in the cache manager' do
+          @cachemgr.should_receive(:store).with(@request, @response)
+          @request.response
+        end
+
+      end
+
+      describe 'not cached' do
+        before do
+          @cachemgr.stub!(:lookup).and_return(nil)
+        end
+
+        it 'should #get the uri from the NetHttpAdapter' do
+          Resourceful::NetHttpAdapter.should_receive(:make_request).
+            with(:get, @uri, nil, anything).and_return(@net_http_adapter_response)
+          @request.response
+        end
+
+        it 'should create a Resourceful::Response object from the NetHttpAdapter response' do
+          Resourceful::Response.should_receive(:new).with(@request.uri, @net_http_adapter_response).and_return(@response)
+          @request.response
+        end
+
+        it 'should store the response in the cache manager' do
+          @cachemgr.should_receive(:store).with(@request, @response)
+          @request.response
+        end
+
+      end
+
+      describe '#set_validation_headers' do
+        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
+
+  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)
+      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
+
+end
+

data/spec/resourceful/resource_spec.rb

@@ -0,0 +1,481 @@
+require 'pathname'
+require Pathname(__FILE__).dirname + '../spec_helper'
+
+require 'resourceful/resource'
+
+describe Resourceful::Resource do
+  before do
+    @accessor = mock('http_accessor', :auth_manager => mock('authmgr', :add_credentials => nil))
+    @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)
+
+    @request = mock('request', :response => @response, :should_be_redirected? => true)
+    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
+  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).and_return(@request)
+      make_request
+    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,
+                                  :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)
+
+        @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)
+          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).twice.and_return(@request)
+        @response.stub!(:is_not_authorized?).and_return(true)
+        make_request
+      end
+
+    end
+
+  end
+
+  describe '#do_write_request' do
+
+    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 '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,
+                                  :code                   => 404)
+        
+        @request.stub!(:response).and_return(@redirect_response, @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", anything)
+        }.should raise_error(Resourceful::UnsuccessfulHttpRequestError)
+      end 
+
+      it 'should give a reasonable error message' do
+        lambda {
+          @resource.do_write_request(:post, "data", anything)
+        }.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
+
+      def make_request
+        @resource.do_write_request(:some_method, "data", {})
+      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
+    
+  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)
+      @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
+
+end
+
+describe Resourceful::Resource do
+
+  describe "#post(body_data, :content_type => content-type)" do
+    before do
+      @auth_manager = mock('auth_manager', :add_credentials => nil)
+      @cache_manager = mock('cache_manager', :lookup => nil, :store => nil)
+      @accessor = mock('accessor', :auth_manager => @auth_manager, :cache_manager => @cache_manager)
+      @resource = Resourceful::Resource.new(@accessor, 'http://foo.invalid/')
+      @response = mock('response', :is_redirect? => false, :is_success? => true)
+      @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
+      @auth_manager = mock('auth_manager', :add_credentials => nil)
+      @cache_manager = mock('cache_manager', :lookup => nil, :store => nil)
+      @accessor = mock('accessor', :auth_manager => @auth_manager, :cache_manager => @cache_manager)
+      @resource = Resourceful::Resource.new(@accessor, 'http://foo.invalid/')
+      @response = mock('response', :is_redirect? => false, :is_success? => true)
+      @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