resourceful 0.2 → 0.2.1

data/Rakefile

@@ -12,6 +12,7 @@ task :test => :spec
 
 desc "Verify Resourceful against it's specs"
 Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
   t.libs << 'lib'
   t.pattern = 'spec/**/*_spec.rb'
 end
@@ -34,7 +35,7 @@ task :clean
 # Packaging & Installation
 ##############################################################################
 
-RESOURCEFUL_VERSION = "0.2"
+RESOURCEFUL_VERSION = "0.2.1"
 
 windows = (PLATFORM =~ /win32|cygwin/) rescue nil
 
@@ -62,7 +63,6 @@ spec = Gem::Specification.new do |s|
   s.add_dependency "addressable"
   s.add_dependency "httpauth"
   s.add_dependency "rspec"
-  s.add_dependency "thin"
   s.add_dependency "facets"
 
   s.required_ruby_version = ">= 1.8.6"
@@ -87,3 +87,7 @@ task :uninstall => :clean do
   sh %{#{SUDO} gem uninstall resourceful}
 end
 
+desc "Update rubyforge documentation"
+task :update_docs do
+  puts %x{rsync -aPz doc/* psadauskas@resourceful.rubyforge.org:/var/www/gforge-projects/resourceful/}
+end

data/lib/resourceful/cache_manager.rb

@@ -27,6 +27,15 @@ module Resourceful
     #   The response to be stored.
     def store(request, response); end
 
+    # Invalidates a all cached entries for a uri. 
+    #
+    # This is used, for example, to invalidate the cache for a resource 
+    # that gets POSTed to.
+    #
+    # @param uri<String>
+    #   The uri of the resource to be invalidated
+    def invalidate(uri); end
+
     # Selects the headers from the request named by the response's Vary header
     # http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.5.6
     #
@@ -37,7 +46,8 @@ module Resourceful
     def select_request_headers(request, response)
       header = Resourceful::Header.new
 
-      response.header['Vary'].each do |name|
+      response.header['Vary'].first.split(',').each do |name|
+        name.strip!
         header[name] = request.header[name]
       end if response.header['Vary']
 
@@ -63,11 +73,11 @@ module Resourceful
   class InMemoryCacheManager < CacheManager
 
     def initialize
-      @collection = Hash.new(CacheEntryCollection.new)
+      @collection = Hash.new{ |h,k| h[k] = CacheEntryCollection.new}
     end
 
     def lookup(request)
-      entry = @collection[request.resource.uri][request]
+      entry = @collection[request.uri.to_s][request]
       response = entry.response if entry
       response.authoritative = false if response
 
@@ -81,7 +91,11 @@ module Resourceful
                              select_request_headers(request, response), 
                              response)
       
-      @collection[request.resource.uri][request] = entry
+      @collection[request.uri.to_s][request] = entry
+    end
+
+    def invalidate(uri)
+      @collection.delete(uri)
     end
 
     # The collection of all cached entries for a single resource (uri). 

data/lib/resourceful/header.rb

@@ -23,7 +23,7 @@ module Resourceful
     end
 
     def capitalize(k)
-      k.to_s.downcase.gsub(/^.|[-_\s]./) { |x| x.upcase }
+      k.to_s.downcase.gsub(/^.|[-_\s]./) { |x| x.upcase }.gsub('_', '-')
     end
   end
 end

data/lib/resourceful/http_accessor.rb

@@ -8,6 +8,22 @@ require 'resourceful/resource'
 require 'resourceful/stubbed_resource_proxy'
 
 module Resourceful
+  # This is an imitation Logger used when no real logger is
+  # registered.  This allows most of the code to assume that there
+  # is always a logger available, which significantly improved the
+  # readability of the logging related code.
+  class BitBucketLogger
+    def warn(*args); end
+    def info(*args); end
+    def debug(*args); end
+  end
+
+  # This is the simplest logger. It just writes everything to STDOUT.
+  class StdOutLogger
+    def warn(*args); puts args; end
+    def info(*args); puts args; end
+    def debug(*args); puts args; end
+  end
   
   # This class provides a simple interface to the functionality
   # provided by the Resourceful library.  Conceptually this object
@@ -15,16 +31,6 @@ module Resourceful
   class HttpAccessor
     RESOURCEFUL_USER_AGENT_TOKEN = "Resourceful/#{RESOURCEFUL_VERSION}(Ruby/#{RUBY_VERSION})"
     
-    # This is an imitation Logger used when no real logger is
-    # registered.  This allows most of the code to assume that there
-    # is always a logger available, which significantly improved the
-    # readability of the logging related code.
-    class BitBucketLogger
-      def warn(*args); end
-      def info(*args); end
-      def debug(*args); end
-    end
-    
     # A logger object to which messages about the activities of this
     # object will be written.  This should be an object that responds
     # to +#info(message)+ and +#debug(message)+.  
@@ -38,7 +44,7 @@ module Resourceful
     attr_reader :user_agent_tokens  
     
     INIT_OPTIONS = OptionsInterpreter.new do 
-      option(:logger, :default => BitBucketLogger.new)
+      option(:logger, :default => Resourceful::BitBucketLogger.new)
       option(:user_agent, :default => []) {|ua| [ua].flatten}
       option(:cache_manager, :default => NullCacheManager.new)
     end

data/lib/resourceful/net_http_adapter.rb

@@ -8,8 +8,10 @@ require Pathname(__FILE__).dirname + 'header'
 module Addressable
   class URI
     def absolute_path
-      absolute_path = self.path.to_s
+      absolute_path = ""
+      absolute_path << self.path.to_s
       absolute_path << "?#{self.query}" if self.query != nil
+      absolute_path << "##{self.fragment}" if self.fragment != nil
       return absolute_path
     end
   end

data/lib/resourceful/request.rb

@@ -1,4 +1,5 @@
 require 'pathname'
+require 'benchmark'
 require Pathname(__FILE__).dirname + 'response'
 require Pathname(__FILE__).dirname + 'net_http_adapter'
 
@@ -21,21 +22,9 @@ module Resourceful
     def response
       @request_time = Time.now
 
-      cached_response = resource.accessor.cache_manager.lookup(self)
-      return cached_response if cached_response and not cached_response.stale?
-
-      set_validation_headers(cached_response) if cached_response and cached_response.stale?
-
       http_resp = NetHttpAdapter.make_request(@method, @resource.uri, @body, @header)
       response = Resourceful::Response.new(uri, *http_resp)
 
-      if response.code == 304
-        cached_response.header.merge(response.header)
-        response = cached_response
-      end
-
-      resource.accessor.cache_manager.store(self, response)
-
       response.authoritative = true
       response
     end
@@ -58,6 +47,10 @@ module Resourceful
     def uri
       resource.uri
     end
+    
+    def logger
+      resource.logger
+    end
 
   end
 

data/lib/resourceful/resource.rb

@@ -75,8 +75,10 @@ module Resourceful
     #
     # @raise [UnsuccessfulHttpRequestError] unless the request is a
     #   success, ie the final request returned a 2xx response code
-    def get
-      do_read_request(:get)
+    def get(header = {})
+      log_request_with_time "GET [#{uri}]" do
+        do_read_request(:get, header)
+      end
     end
 
     # :call-seq:
@@ -98,7 +100,9 @@ module Resourceful
     def post(data = "", options = {})
       raise ArgumentError, ":content_type must be specified" unless options.has_key?(:content_type)
 
-      do_write_request(:post, data, {'Content-Type' => options[:content_type]})
+      log_request_with_time "POST [#{uri}]" do
+        do_write_request(:post, data, options)
+      end
     end
 
     # :call-seq:
@@ -120,7 +124,9 @@ module Resourceful
     def put(data = "", options = {})
       raise ArgumentError, ":content_type must be specified" unless options.has_key?(:content_type)
 
-      do_write_request(:put, data, {'Content-Type' => options[:content_type]})
+      log_request_with_time "PUT [#{uri}]" do
+        do_write_request(:put, data, options)
+      end
     end
 
     # Performs a DELETE on the resource, following redirects as neccessary.
@@ -129,8 +135,10 @@ module Resourceful
     #
     # @raise [UnsuccessfulHttpRequestError] unless the request is a
     #   success, ie the final request returned a 2xx response code
-    def delete
-      do_write_request(:delete, {}, nil)
+    def delete(options = {})
+      log_request_with_time "DELETE [#{uri}]" do
+        do_write_request(:delete, {}, options)
+      end
     end
 
     # Performs a read request (HEAD, GET). Users should use the #get, etc methods instead.
@@ -144,32 +152,51 @@ module Resourceful
     # @raise [UnsuccessfulHttpRequestError] unless the request is a
     #   success, ie the final request returned a 2xx response code
     #
-    # --
-    # @private
-    def do_read_request(method)
-      request = Resourceful::Request.new(method, self)
+    def do_read_request(method, header = {})
+      request = Resourceful::Request.new(method, self, nil, header)
       accessor.auth_manager.add_credentials(request)
 
+      cached_response = accessor.cache_manager.lookup(request)
+      if cached_response
+        logger.debug("    Retrieved from cache")
+        if not cached_response.stale?
+          # We're done!
+          return cached_response
+        else
+          logger.debug("    Cache entry is stale")
+          request.set_validation_headers(cached_response)
+        end
+      end
+
       response = request.response
 
+      if response.is_not_modified?
+        cached_response.header.merge(response.header)
+        response = cached_response
+        response.authoritative = true
+      end
+
       if response.is_redirect? and request.should_be_redirected?
         if response.is_permanent_redirect?
           @uris.unshift response.header['Location'].first
-          response = do_read_request(method)
+          response = do_read_request(method, header)
         else
           redirected_resource = Resourceful::Resource.new(self.accessor, response.header['Location'].first)
-          response = redirected_resource.do_read_request(method)
+          response = redirected_resource.do_read_request(method, header)
         end
       end
 
       if response.is_not_authorized? && !@already_tried_with_auth
         @already_tried_with_auth = true
         accessor.auth_manager.associate_auth_info(response)
-        response = do_read_request(method)
+        logger.debug("Authentication Required. Retrying with auth info")
+        response = do_read_request(method, header)
       end
 
       raise UnsuccessfulHttpRequestError.new(request,response) unless response.is_success?
 
+      accessor.cache_manager.store(request, response) if response.is_success?
+
       return response
     end
 
@@ -186,31 +213,50 @@ module Resourceful
     #
     # @raise [UnsuccessfulHttpRequestError] unless the request is a
     #   success, ie the final request returned a 2xx response code
-    # --
-    # @private
     def do_write_request(method, data = nil, header = {})
       request = Resourceful::Request.new(method, self, data, header)
       accessor.auth_manager.add_credentials(request)
 
       response = request.response
-      
+
       if response.is_redirect? and request.should_be_redirected?
         if response.is_permanent_redirect?
           @uris.unshift response.header['Location'].first
           response = do_write_request(method, data, header)
         elsif response.code == 303 # see other, must use GET for new location
           redirected_resource = Resourceful::Resource.new(self.accessor, response.header['Location'].first)
-          response = redirected_resource.do_read_request(:get)
+          response = redirected_resource.do_read_request(:get, header)
         else
           redirected_resource = Resourceful::Resource.new(self.accessor, response.header['Location'].first)
           response = redirected_resource.do_write_request(method, data, header)
         end
       end
 
+      if response.is_not_authorized? && !@already_tried_with_auth
+        @already_tried_with_auth = true
+        accessor.auth_manager.associate_auth_info(response)
+        logger.debug("Authentication Required. Retrying with auth info")
+        response = do_write_request(method, data, header)
+      end
+
       raise UnsuccessfulHttpRequestError.new(request,response) unless response.is_success?
+
+      accessor.cache_manager.invalidate(uri)
       return response
     end
 
+    def log_request_with_time(msg, indent = 2)
+      logger.info(" " * indent + msg)
+      result = nil
+      time = Benchmark.measure { result = yield }
+      logger.info(" " * indent + "-> Returned #{result.code} in %.4fs" % time.real)
+      result
+    end
+
+    def logger
+      accessor.logger
+    end
+
   end
 
 end

data/lib/resourceful/response.rb

@@ -2,6 +2,7 @@ require 'net/http'
 require 'time'
 require 'rubygems'
 require 'facets/kernel/ergo'
+require 'zlib'
 
 module Resourceful
   # Exception indicating that the server used a content coding scheme
@@ -23,35 +24,105 @@ module Resourceful
       @response_time = Time.now
     end
 
+    # Is the response code sucessful? True for only 2xx series
+    # response codes.
+    #
+    # @return true|false
     def is_success?
       @code.in? 200..299
     end
+    alias was_successful? is_success?
+
+    # Is the response the result of a server error? True for
+    # 5xx series response codes
+    #
+    # @return true|false
+    def is_server_error?
+      @code.in? 500..599
+    end
+    alias was_server_error? is_server_error?
+
+    # Is the response the result of a client error? True for
+    # 4xx series response codes
+    #
+    # @return true|false
+    def is_client_error?
+      @code.in? 400..499
+    end
+    alias was_client_error? is_client_error?
+
+    # Is the response the result of any kind of error? True for
+    # 4xx and 5xx series response codes
+    #
+    # @return true|false
+    def is_error?
+      is_server_error? || is_client_error?
+    end
+    alias was_error? is_error?
+
+    # Is the response not a success? True for
+    # 3xx, 4xx and 5xx series response codes
+    #
+    # @return true|false
+    def is_unsuccesful?
+      is_error? || is_redirect?
+    end
+    alias was_unsuccessful? is_unsuccesful?
 
+    # Is the response a redirect response code? True for
+    # 3xx codes that are redirects (301, 302, 303, 307)
+    #
+    # @return true|false
     def is_redirect?
       @code.in? REDIRECT_RESPONSE_CODES
     end
     alias was_redirect? is_redirect?
 
+    # Is the response a Permanent Redirect (301) ?
+    #
+    # @return true|false
     def is_permanent_redirect?
       @code == 301
     end
 
+    # Is the response a Temporary Redirect (anything but 301) ?
+    #
+    # @return true|false
     def is_temporary_redirect?
       is_redirect? and not is_permanent_redirect?
     end
 
+    # Is the response a client error of Not Authorized (401) ?
+    #
+    # @return true|false
     def is_not_authorized?
       @code == 401
     end
 
+    # Is the response not modified (304) ?
+    #
+    # @return true|false
+    def is_not_modified?
+      @code == 304
+    end
+  
+    # Is this a cached response that has expired?
+    #
+    # @return true|false
     def expired?
       if header['Expire']
         return true if Time.httpdate(header['Expire'].first) < Time.now
       end
+      if header['Cache-Control'] and header['Cache-Control'].include?('max-age')
+        return true if current_age > max_age
+      end
 
       false
     end
 
+    # Is this a cached response that is stale?
+    #
+    # @return true|false
     def stale?
       return true if expired?
       if header['Cache-Control']
@@ -62,6 +133,9 @@ module Resourceful
       false
     end
 
+    # Is this response cachable?
+    #
+    # @return true|false
     def cachable?
       return false if header['Vary'] and header['Vary'].include?('*')
       return false if header['Cache-Control'] and header['Cache-Control'].include?('no-store')
@@ -86,7 +160,7 @@ module Resourceful
         # body is identity encoded; just return it
         @body
       when /^\s*gzip\s*$/i
-        gz_in = Zlib::GzipReader.new(StringIO.new(@body, 'r'))
+        gz_in = ::Zlib::GzipReader.new(StringIO.new(@body, 'r'))
         @body = gz_in.read
         gz_in.close
         header.delete('Content-Encoding')

data/spec/acceptance_spec.rb

@@ -23,6 +23,14 @@ describe Resourceful do
       resp.header['Content-Type'].should == ['text/plain']
     end
 
+    it 'should set additional headers on the #get' do
+      resource = @accessor.resource('http://localhost:3000/echo_header')
+      resp = resource.get(:foo => :bar)
+      resp.should be_instance_of(Resourceful::Response)
+      resp.code.should == 200
+      resp.body.should =~ /"HTTP_FOO"=>"bar"/
+    end
+
     it 'should #post a resource, and return the response' do
       resource = @accessor.resource('http://localhost:3000/post')
       resp = resource.post('Hello world from POST', :content_type => 'text/plain')
@@ -191,6 +199,17 @@ describe Resourceful do
         resp2.should == resp
       end
 
+      it 'should not use a cached document for a resource that has been posted to' do
+        resource = @accessor.resource('http://localhost:3000/get')
+        resp = resource.get
+        resp.authoritative?.should be_true
+
+        resource.post("foo", :content_type => 'text/plain')
+
+        resp2 = resource.get
+        resp2.should_not == resp
+      end
+
       describe 'Cache-Control' do
 
         it 'should cache anything with "Cache-Control: public"' do

data/spec/resourceful/cache_manager_spec.rb

@@ -20,6 +20,10 @@ describe Resourceful::CacheManager do
     @cm.should respond_to(:store)
   end
 
+  it 'should have a invalidate method' do
+    @cm.should respond_to(:invalidate)
+  end
+
   describe '#select_request_headers' do
     before do
       @req_header = mock('header', :[] => nil)
@@ -35,7 +39,7 @@ describe Resourceful::CacheManager do
     end
 
     it 'should pull the values from the request that match keys in the vary header' do
-      @resp_header.should_receive(:[]).with('Vary').twice.and_return(['foo', 'bar'])
+      @resp_header.should_receive(:[]).with('Vary').twice.and_return(['foo, bar'])
       @req_header.should_receive(:[]).with('foo').and_return('oof')
       @req_header.should_receive(:[]).with('bar').and_return('rab')
 
@@ -64,16 +68,16 @@ describe Resourceful::NullCacheManager do
     @ncm.should respond_to(:store)
 
     lambda { @ncm.store(:foo, :bar) }.should_not raise_error
-
   end
 
 end
 
 describe Resourceful::InMemoryCacheManager do
   before do
-    @request = mock('request', :resource => mock('resource', :uri => 'uri'),
-                               :request_time => Time.utc(2008,5,22,15,00))
-    @response = mock('response', :header => {})
+    @request = mock('request', :resource => mock('resource'),
+                               :request_time => Time.utc(2008,5,22,15,00),
+                               :uri => 'uri')
+    @response = mock('response', :header => {}, :cachable? => true)
 
     @entry = mock('cache entry', :response => @response, :valid_for? => true)
     Resourceful::InMemoryCacheManager::CacheEntry.stub!(:new).and_return(@entry)
@@ -98,10 +102,6 @@ describe Resourceful::InMemoryCacheManager do
   end
 
   describe 'saving' do
-    before do
-      @response.stub!(:cachable?).and_return(true)
-    end
-
     it 'should make a new cache entry' do
       Resourceful::InMemoryCacheManager::CacheEntry.should_receive(:new).with(
         Time.utc(2008,5,22,15,00),
@@ -131,6 +131,15 @@ describe Resourceful::InMemoryCacheManager do
     end
   end
 
+  describe 'invalidating' do
+    it 'should remove an entry from the cache by uri' do
+      @imcm.store(@request, @response)
+      @imcm.invalidate('uri')
+      col = @imcm.instance_variable_get("@collection")
+      col.should_not have_key('uri')
+    end
+  end
+
 end
 
 describe Resourceful::InMemoryCacheManager::CacheEntryCollection do

data/spec/resourceful/header_spec.rb

@@ -23,7 +23,7 @@ describe Resourceful::Header do
 
     h.capitalize("foo").should == "Foo"
     h.capitalize("foo-bar").should == "Foo-Bar"
-    h.capitalize("foo_bar").should == "Foo_Bar"
+    h.capitalize("foo_bar").should == "Foo-Bar"
     h.capitalize("foo bar").should == "Foo Bar"
     h.capitalize("foo-bar-quux").should == "Foo-Bar-Quux"
     h.capitalize("foo-bar-2quux").should == "Foo-Bar-2quux"

data/spec/resourceful/http_accessor_spec.rb

@@ -18,7 +18,7 @@ describe Resourceful::HttpAccessor, 'init' do
   it 'should provide logger object even when no logger is specified' do
     ha = Resourceful::HttpAccessor.new()
     
-    ha.logger.should be_instance_of(Resourceful::HttpAccessor::BitBucketLogger)
+    ha.logger.should be_instance_of(Resourceful::BitBucketLogger)
   end 
 
   it 'should raise arg error if unrecognized options are passed' do

data/spec/resourceful/net_http_adapter_spec.rb

@@ -87,4 +87,10 @@ describe Addressable::URI, '#absolute_path monkey patch' do
     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/request_spec.rb

@@ -6,7 +6,7 @@ require 'addressable/uri'
 describe Resourceful::Request do
   before do
     @uri = Addressable::URI.parse('http://www.example.com')
-    @resource = mock('resource')
+    @resource = mock('resource', :logger => Resourceful::BitBucketLogger.new)
     @resource.stub!(:uri).and_return(@uri)
 
     @request = Resourceful::Request.new(:get, @resource)
@@ -14,7 +14,7 @@ describe Resourceful::Request do
     @cachemgr = mock('cache_mgr')
     @cachemgr.stub!(:lookup).and_return(nil)
     @cachemgr.stub!(:store)
-    @resource.stub!(:accessor).and_return(mock('accessor', :cache_manager => @cachemgr))
+    @resource.stub!(:accessor).and_return(mock('accessor', :cache_manager => @cachemgr, :logger => Resourceful::BitBucketLogger.new))
   end
 
   describe 'init' do
@@ -50,7 +50,7 @@ describe Resourceful::Request 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)
+      @response = mock('response', :code => 200, :authoritative= => true, :was_unsuccessful? => false)
       Resourceful::Response.stub!(:new).and_return(@response)
     end
 
@@ -63,145 +63,13 @@ describe Resourceful::Request do
     end
 
     it 'should set the request_time to now' do
-      now = mock('now')
+      now = Time.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
@@ -209,7 +77,7 @@ describe Resourceful::Request 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)
+      @response = mock('response', :code => 200, :authoritative= => true, :was_unsuccessful? => false)
       Resourceful::Response.stub!(:new).and_return(@response)
     end
 
@@ -257,5 +125,55 @@ describe Resourceful::Request do
     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

@@ -5,13 +5,23 @@ require 'resourceful/resource'
 
 describe Resourceful::Resource do
   before do
-    @accessor = mock('http_accessor', :auth_manager => mock('authmgr', :add_credentials => nil))
+    @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)
+    @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)
+    @request = mock('request', :response => @response, :should_be_redirected? => true, :uri => @uri)
     Resourceful::Request.stub!(:new).and_return(@request)
   end
 
@@ -48,10 +58,15 @@ describe Resourceful::Resource do
     end
 
     it 'should make a new request object from the method' do
-      Resourceful::Request.should_receive(:new).with(:some_method, @resource).and_return(@request)
+      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 'non-success responses' do
       before do
         @uri      = 'http://www.example.com/code/404'
@@ -63,6 +78,7 @@ describe Resourceful::Resource do
                                   :is_redirect?           => false,
                                   :is_success?            => false,
                                   :is_not_authorized?     => false,
+                                  :is_not_modified?       => false,
                                   :code                   => 404)
         
         @request.stub!(:response).and_return(@redirect_response, @response)
@@ -92,7 +108,8 @@ describe Resourceful::Resource do
         @redirect_response = mock('redirect_response',
                                   :header                 => {'Location' => [@redirected_uri]},
                                   :is_redirect?           => true,
-                                  :is_permanent_redirect? => true)
+                                  :is_permanent_redirect? => true,
+                                  :is_not_modified?       => false)
 
         @request.stub!(:response).and_return(@redirect_response, @response)
 
@@ -182,17 +199,54 @@ describe Resourceful::Resource do
       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)
+        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")
@@ -244,10 +298,6 @@ describe Resourceful::Resource do
 
       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
@@ -311,15 +361,47 @@ describe Resourceful::Resource do
           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)
+            @new_resource.should_receive(:do_read_request).with(:get, {}).and_return(@response)
             make_request
           end
         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
@@ -352,7 +434,7 @@ describe Resourceful::Resource do
     end
 
     it 'should pass :get to the #do_read_request method' do
-      @resource.should_receive(:do_read_request).with(:get)
+      @resource.should_receive(:do_read_request).with(:get, {}).and_return(@response)
       @resource.get
     end
 
@@ -374,17 +456,10 @@ describe Resourceful::Resource do
 
   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)
+      @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
@@ -397,7 +472,10 @@ describe Resourceful::Resource do
 
     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')).
+        with(anything,
+             anything, 
+             anything, 
+             hash_including(:content_type =>'text/plain')).
         and_return(@request)
 
       @resource.post("a body", :content_type => 'text/plain') 
@@ -430,11 +508,8 @@ describe Resourceful::Resource do
 
   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)
+      @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
@@ -447,7 +522,10 @@ describe Resourceful::Resource do
 
     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')).
+        with(anything,
+             anything, 
+             anything, 
+             hash_including(:content_type =>'text/plain')).
         and_return(@request)
 
       @resource.put("a body", :content_type => 'text/plain') 

data/spec/resourceful/response_spec.rb

@@ -58,6 +58,45 @@ describe Resourceful::Response do
     end 
   end 
 
+  describe '#is_unsuccesful?' do
+    it 'should be true for a 4xx series response code' do
+      Resourceful::Response.new(@uri, 404, {}, "").is_unsuccesful?.should == true
+    end
+
+    it 'should be true for a 5xx series response code' do
+      Resourceful::Response.new(@uri, 500, {}, "").is_unsuccesful?.should == true
+    end
+
+    it 'should be not true for a 2xx series response code' do
+      Resourceful::Response.new(@uri, 200, {}, "").is_unsuccesful?.should == false
+    end
+
+    it 'should be true for a 3xx series response code' do
+      Resourceful::Response.new(@uri, 302, {}, "").is_unsuccesful?.should == true
+    end
+  end
+
+  describe '#is_client_error?' do
+    it 'be true for a 4xx series response code' do
+      Resourceful::Response.new(@uri, 404, {}, "").is_client_error?.should == true
+    end
+
+    it 'be false for anything else' do
+      Resourceful::Response.new(@uri, 200, {}, "").is_client_error?.should == false
+    end
+  end
+
+  describe '#is_server_error?' do
+    it 'be true for a 5xx series response code' do
+      Resourceful::Response.new(@uri, 500, {}, "").is_server_error?.should == true
+    end
+
+    it 'be false for anything else' do
+      Resourceful::Response.new(@uri, 200, {}, "").is_server_error?.should == false
+    end
+  end
+
+
   it 'should know if it is a redirect' do
     Resourceful::Response.new(@uri, 301, {}, "").is_redirect?.should == true
     Resourceful::Response.new(@uri, 302, {}, "").is_redirect?.should == true

data/spec/simple_http_server_shared_spec.rb

@@ -35,7 +35,7 @@ CodeResponder = lambda do |env|
   [ code, {'Content-Type' => 'text/plain', 'Content-Length' => body.join.size.to_s}, body ]
 end unless defined? CodeResponder
 
-# YAML-parses the quesy string (expected hash) and sets the header to that
+# YAML-parses the query string (expected hash) and sets the header to that
 HeaderResponder = lambda do |env|
   header = YAML.load(URI.unescape(env['QUERY_STRING']))
   body = [header.inspect]
@@ -48,6 +48,18 @@ HeaderResponder = lambda do |env|
   [ 200, header, body ]
 end unless defined? HeaderResponder
 
+# Echos the request header in the response body
+EchoHeaderResponder = lambda do |env|
+  body = [env.inspect]
+
+  header = {
+            'Content-Type' => 'text/plain', 
+            'Content-Length' => body.join.size.to_s
+           }
+
+  [ 200, header, body ]
+end unless defined? EchoHeaderResponder
+
 # redirect. /redirect/{301|302}?{url}
 Redirector = lambda do |env|
   code = env['PATH_INFO'] =~ /([\d]+)/ ? Integer($1) : 404
@@ -114,7 +126,6 @@ describe 'simple http server', :shared => true do
     #setup a thin http server we can connect to
     require 'thin'
     require 'rack'
-    require 'rack/lobster'
 
     app = Rack::Builder.new do |env|
       use Rack::ShowExceptions
@@ -128,6 +139,7 @@ describe 'simple http server', :shared => true do
       map( '/code'     ){ run CodeResponder }
       map( '/redirect' ){ run Redirector }
       map( '/header'   ){ run HeaderResponder }
+      map( '/echo_header' ){ run EchoHeaderResponder }
       map( '/modified' ){ run ModifiedResponder }
       map( '/auth'     ){ run AuthorizationResponder }
     end

data/spec/simple_http_server_shared_spec_spec.rb

@@ -65,6 +65,14 @@ describe 'http server' do
     resp[1]['Expire'].first.should_not =~ /%/
   end
 
+  it 'should echo the request header in the response body' do
+    uri = URI.escape("http://localhost:3000/echo_header")
+
+    resp = Resourceful::NetHttpAdapter.make_request(:get, uri)
+
+    resp[2].should =~ /HTTP_HOST/
+  end
+
   describe '/modified' do
     it 'should be 200 if no I-M-S header' do
       uri = URI.escape("http://localhost:3000/modified?#{(Time.now + 3600).httpdate}")

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--color
+--format progress
+

data/spec/spec_helper.rb

@@ -4,8 +4,11 @@ require 'spec'
 require 'pp'
 require 'facets'
 
-$LOAD_PATH << Pathname(__FILE__).dirname + "../lib"
+#$LOAD_PATH << Pathname(__FILE__).dirname + "../lib"
+$LOAD_PATH << File.dirname(__FILE__) + "../lib"
 require 'resourceful/util'
+require 'resourceful'
+require 'resourceful/http_accessor'
 
 require Pathname(__FILE__).dirname + 'simple_http_server_shared_spec'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: resourceful
 version: !ruby/object:Gem::Version 
-  version: "0.2"
+  version: 0.2.1
 platform: ruby
 authors: 
 - Paul Sadauskas & Peter Williams
@@ -9,11 +9,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-30 00:00:00 -06:00
+date: 2008-07-31 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: addressable
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -23,6 +24,7 @@ dependencies:
     version: 
 - !ruby/object:Gem::Dependency 
   name: httpauth
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -32,15 +34,7 @@ dependencies:
     version: 
 - !ruby/object:Gem::Dependency 
   name: rspec
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: thin
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -50,6 +44,7 @@ dependencies:
     version: 
 - !ruby/object:Gem::Dependency 
   name: facets
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -70,6 +65,7 @@ files:
 - README.markdown
 - Rakefile
 - spec/acceptance_shared_specs.rb
+- spec/spec.opts
 - spec/acceptance_spec.rb
 - spec/simple_http_server_shared_spec_spec.rb
 - spec/spec_helper.rb
@@ -121,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: resourceful
-rubygems_version: 1.1.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: Resourceful provides a convenient Ruby API for making HTTP requests.