resourceful 0.2.1 → 0.3.0

data/spec/resourceful/cache_manager_spec.rb

@@ -2,8 +2,8 @@ require 'pathname'
 require Pathname(__FILE__).dirname + '../spec_helper'
 
 require 'resourceful/cache_manager'
-
-describe Resourceful::CacheManager do
+ 
+describe Resourceful::AbstractCacheManager do
   before do
     @cm = Resourceful::InMemoryCacheManager.new #cheat, because I cant new a real one. 
   end
@@ -19,40 +19,10 @@ describe Resourceful::CacheManager do
   it 'should have a store method' 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)
-      @request = mock('request', :header => @req_header)
-
-      @resp_header = mock('header', :[] => nil)
-      @response = mock('response', :header => @resp_header)
-    end
-
-    it 'should select the request headers from the Vary header' do
-      @resp_header.should_receive(:[]).with('Vary')
-      @cm.select_request_headers(@request, @response)
-    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'])
-      @req_header.should_receive(:[]).with('foo').and_return('oof')
-      @req_header.should_receive(:[]).with('bar').and_return('rab')
-
-      header = @cm.select_request_headers(@request, @response)
-      header['foo'].should == 'oof'
-      header['bar'].should == 'rab'
-    end
-
-    it 'should return a new Header object' do
-      @cm.select_request_headers(@request, @response).should be_kind_of(Resourceful::Header)
-    end
-  end
-
 end
 
 describe Resourceful::NullCacheManager do
@@ -80,7 +50,7 @@ describe Resourceful::InMemoryCacheManager do
     @response = mock('response', :header => {}, :cachable? => true)
 
     @entry = mock('cache entry', :response => @response, :valid_for? => true)
-    Resourceful::InMemoryCacheManager::CacheEntry.stub!(:new).and_return(@entry)
+    Resourceful::CacheEntry.stub!(:new).and_return(@entry)
 
     @imcm = Resourceful::InMemoryCacheManager.new
   end
@@ -88,7 +58,7 @@ describe Resourceful::InMemoryCacheManager do
   describe 'finding' do
     before do
       @response.stub!(:authoritative=)
-      @imcm.instance_variable_set("@collection", {'uri' => {@request => @entry}})
+      @imcm.instance_variable_set("@collection", {'uri' => {@request => @response}})
     end
 
     it 'should lookup the response by request' do
@@ -103,9 +73,8 @@ describe Resourceful::InMemoryCacheManager do
 
   describe 'saving' do
     it 'should make a new cache entry' do
-      Resourceful::InMemoryCacheManager::CacheEntry.should_receive(:new).with(
-        Time.utc(2008,5,22,15,00),
-        {},
+      Resourceful::CacheEntry.should_receive(:new).with(
+        @request,
         @response
       )
 
@@ -115,7 +84,7 @@ describe Resourceful::InMemoryCacheManager do
     it 'should store the response entity by request' do
       @imcm.store(@request, @response)
       col = @imcm.instance_variable_get("@collection")
-      col['uri'][@request].response.should == @response
+      col['uri'][@request].should == @response
     end
 
     it 'should check if the response is cachable' do
@@ -142,20 +111,21 @@ describe Resourceful::InMemoryCacheManager do
 
 end
 
-describe Resourceful::InMemoryCacheManager::CacheEntryCollection do
+describe Resourceful::CacheEntryCollection do
   before do
-    @entry_valid   = mock('entry', :valid_for? => true)
-    @entry_invalid = mock('entry', :valid_for? => false)
+    @request = mock('request', :uri => 'this', :request_time => Time.now, :header => {})
+    @valid_resp = stub('valid_resp', :authoritative= => nil, :header => {})
 
-    @request = mock('request')
+    @entry_valid   = mock('entry', :valid_for? => true, :response => @valid_resp)
+    @entry_invalid = mock('entry', :valid_for? => false, :response => stub('invalid_resp'))
 
-    @collection = Resourceful::InMemoryCacheManager::CacheEntryCollection.new
+    @collection = Resourceful::CacheEntryCollection.new
   end
 
   it 'should find the right entry for a request' do
     @collection.instance_variable_set('@entries', [@entry_valid, @entry_invalid])
     @entry_valid.should_receive(:valid_for?).with(@request).and_return(true)
-    @collection[@request].should == @entry_valid
+    @collection[@request].should == @valid_resp
   end
 
   it 'should be nil if no matching entry was found' do
@@ -165,47 +135,89 @@ describe Resourceful::InMemoryCacheManager::CacheEntryCollection do
   end
 
   it 'should store an entry' do
-    @collection[@request] = @entry_valid
-    @collection.instance_variable_get("@entries").should include(@entry_valid)
+    @collection[@request] = @valid_resp
+    @collection.instance_variable_get("@entries").should have(1).items
   end
 
   it 'should replace an existing entry if the existing entry matches the request' do
-    @new_entry = mock('entry', :valid_for? => true)
+    new_resp = stub('new_resp', :authoritative= => nil, :header => {})
 
-    @collection[@request] = @entry_valid
-    @collection[@request] = @new_entry
+    @collection[@request] = @valid_resp
+    @collection[@request] = new_resp
 
-    @collection.instance_variable_get("@entries").should include(@new_entry)
-    @collection.instance_variable_get("@entries").should_not include(@entry_valid)
+    @collection.instance_variable_get("@entries").map{|it| it.response}.should include(new_resp)
+    @collection.instance_variable_get("@entries").map{|it| it.response}.should_not include(@valid_resp)
   end
 
 end
 
-describe Resourceful::InMemoryCacheManager::CacheEntry do
+describe Resourceful::CacheEntry do
   before do
-    @entry = Resourceful::InMemoryCacheManager::CacheEntry.new(
-      Time.utc(2008,5,16,0,0,0), {'Content-Type' => 'text/plain'}, mock('response')
+    @entry = Resourceful::CacheEntry.new(
+      mock('original_request', :header => {'Accept' => 'text/plain'} , 
+           :request_time => Time.utc(2008,5,16,0,0,0), :uri => 'http://foo.invalid'), 
+      mock('response', :header => {'Vary' => 'Accept'})
     )
 
-    @request = mock('request')
+    @request = mock('request', :uri => 'http://foo.invalid')
   end
 
-  [:request_time, :request_vary_headers, :response, :valid_for?].each do |method|
-    it "should respond to ##{method}" do
-      @entry.should respond_to(method)
+  describe "#valid_for?(a_request)" do 
+    it "should true for request to URI w/ matching header " do
+      @entry.valid_for?(mock("new_request", 
+                             :uri => 'http://foo.invalid', 
+                             :header => {'Accept' => 'text/plain'})).should be_true
+    end 
+
+    it "should false for requests against different URIs even if headers match" do
+      @entry.valid_for?(mock("new_request", :uri => 'http://bar.invalid', 
+                             :header => {'Accept' => 'text/plain'})).should be_false
+    end 
+
+    it "should false for requests where headers don't match" do
+      @entry.valid_for?(mock("new_request", :uri => 'http://foo.invalid', 
+                             :header => {'Accept' => 'application/octet-stream'})).should be_false
+    end 
+
+    it "should be false if request has a varying header and the original request was missing that header" do 
+      entry = Resourceful::CacheEntry.new(
+                 mock('original_request', :header => {}, 
+                      :request_time => Time.utc(2008,5,16,0,0,0), :uri => 'http://foo.invalid'), 
+                 mock('response', :header => {'Vary' => 'Accept'}))
+
+      entry.valid_for?(mock("new_request", :uri => 'http://foo.invalid', 
+                             :header => {'Accept' => 'text/plain'})).should be_false
     end
   end
 
-  it 'should be valid for a request if all the vary headers match' do
-    @request.stub!(:header).and_return({'Content-Type' => 'text/plain'})
-    @entry.valid_for?(@request).should be_true
-  end
+  describe '#select_request_headers' do
+    before do
+      @req_header = mock('header', :[] => nil)
+      @request = mock('request', :header => @req_header)
 
-  it 'should not be valid for a request if not all the vary headers match' do
-    @request.stub!(:header).and_return({'Content-Type' => 'text/html'})
-    @entry.valid_for?(@request).should be_false
-  end
+      @resp_header = mock('header', :[] => nil)
+      @response = mock('response', :header => @resp_header)
+    end
+
+    it 'should select the request headers from the Vary header' do
+      @resp_header.should_receive(:[]).with('Vary')
+      @entry.select_request_headers(@request, @response)
+    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'])
+      @req_header.should_receive(:[]).with('foo').and_return('oof')
+      @req_header.should_receive(:[]).with('bar').and_return('rab')
 
+      header = @entry.select_request_headers(@request, @response)
+      header['foo'].should == 'oof'
+      header['bar'].should == 'rab'
+    end
+
+    it 'should return a new Header object' do
+      @entry.select_request_headers(@request, @response).should be_kind_of(Resourceful::Header)
+    end
+  end
 end
 
 

data/spec/resourceful/http_accessor_spec.rb

@@ -23,20 +23,26 @@ describe Resourceful::HttpAccessor, 'init' do
 
   it 'should raise arg error if unrecognized options are passed' do
     lambda {
-      ha = Resourceful::HttpAccessor.new(:foo => 'foo', :bar => 'bar')
+      Resourceful::HttpAccessor.new(:foo => 'foo', :bar => 'bar')
     }.should raise_error(ArgumentError, /Unrecognized options: (foo, bar)|(bar, foo)/)
   end 
 
   it 'should allow an additional user agent token to be passed at init' do
-    Resourceful::HttpAccessor.new(:user_agent => "Super/3000").tap do |ha|
-      ha.user_agent_string.should match(%r{^Super/3000})
-    end
+    ha = Resourceful::HttpAccessor.new(:user_agent => "Super/3000")
+
+    ha.user_agent_string.should match(%r{^Super/3000})
   end 
 
   it 'should allow multiple additional user agent tokens to be passed at init' do
-    Resourceful::HttpAccessor.new(:user_agent => ["Super/3000", "Duper/2.1"]).tap do |ha|
-      ha.user_agent_string.should match(%r{^Super/3000 Duper/2\.1 })
-    end
+    ha = Resourceful::HttpAccessor.new(:user_agent => ["Super/3000", "Duper/2.1"])
+
+    ha.user_agent_string.should match(%r{^Super/3000 Duper/2\.1 })
+  end 
+
+  it 'should allow cache manager to be provided at init' do
+    ha = Resourceful::HttpAccessor.new(:cache_manager => :marker)
+
+    ha.cache_manager.should equal(:marker)
   end 
 
 end 
@@ -87,13 +93,13 @@ describe Resourceful::HttpAccessor do
   end 
 
   it 'should pass uri to resource upon creation (#[])' do
-    Resourceful::Resource.should_receive(:new).with(anything, 'http://www.example/previously-unused-uri').
+    Resourceful::Resource.should_receive(:new).with(anything, 'http://www.example/previously-unused-uri', anything).
       and_return(stub('resource'))
     @accessor['http://www.example/previously-unused-uri']
   end 
   
   it 'should pass owning accessor to resource upon creation (#[])' do
-    Resourceful::Resource.should_receive(:new).with(@accessor, anything).and_return(stub('resource'))
+    Resourceful::Resource.should_receive(:new).with(@accessor, anything, anything).and_return(stub('resource'))
     @accessor['http://www.example/previously-unused-uri']
   end 
 
@@ -107,14 +113,52 @@ describe Resourceful::HttpAccessor do
   end 
 
   it 'should pass owning accessor to resource upon creation (#[])' do
-    Resourceful::Resource.should_receive(:new).with(@accessor, anything).and_return(stub('resource'))
+    Resourceful::Resource.should_receive(:new).with(@accessor, anything, anything).and_return(stub('resource'))
     @accessor.resource('http://www.example/previously-unused-uri')
   end 
 
   it 'should pass uri to resource upon creation (#resource)' do
-    Resourceful::Resource.should_receive(:new).with(anything, 'http://www.example/previously-unused-uri').
+    Resourceful::Resource.should_receive(:new).with(anything, 'http://www.example/previously-unused-uri', anything).
       and_return(stub('resource'))
     @accessor.resource('http://www.example/previously-unused-uri')
   end 
 
+  it 'should pass additional options to resource upon creation' do
+    Resourceful::Resource.should_receive(:new).with(anything, anything, :foo => :bar).and_return(stub('resource'))
+    @accessor.resource('http://example.com/', :foo => :bar)
+  end
+
 end
+
+describe Resourceful::HttpAccessor, "(authentication)" do           
+  before do
+    @auth_manager = stub('auth_manager', :add_auth_handler => nil)
+    Resourceful::AuthenticationManager.stub!(:new).and_return(@auth_manager)
+    @ha = Resourceful::HttpAccessor.new()
+  end
+
+  it 'should allow authenticators to be registered' do
+    an_authenticator = stub('an_authenicator')
+    @auth_manager.should_receive(:add_auth_handler).with(an_authenticator)
+
+    @ha.add_authenticator(an_authenticator)
+  end 
+
+  it 'should allow an authenicator to be specified at init' do
+    an_authenticator = stub('an_authenicator')
+    @auth_manager.should_receive(:add_auth_handler).with(an_authenticator)
+
+    Resourceful::HttpAccessor.new(:authenticator => an_authenticator)
+  end 
+
+  it 'should allow multiple authenicators to be specified at init' do
+    authenticator1 = stub('authenicator1')
+    authenticator2 = stub('authenicator2')
+
+    @auth_manager.should_receive(:add_auth_handler).with(authenticator1)
+    @auth_manager.should_receive(:add_auth_handler).with(authenticator2)
+
+    Resourceful::HttpAccessor.new(:authenticators => [authenticator1, authenticator2])
+  end 
+
+end 

data/spec/resourceful/memcache_cache_manager_spec.rb

@@ -0,0 +1,111 @@
+require 'pathname'
+require Pathname(__FILE__).dirname + '../spec_helper'
+
+require 'resourceful/memcache_cache_manager'
+require 'resourceful/request'
+
+describe Resourceful::MemcacheCacheManager do
+  before do
+    @resource = stub('resource', :uri => 'http://foo.invalid/')
+
+    @request = Resourceful::Request.new(:get, @resource)
+    @response = Resourceful::Response.new('http://foo.invalid/', '200', {'Vary' => 'Accept'}, "a body")
+    
+    @memcache = stub('memcache', :get => nil)
+    MemCache.stub!(:new).and_return(@memcache)
+
+    @cache_mngr = Resourceful::MemcacheCacheManager.new('foobar:42')
+  end
+
+  describe "#store(request,response)" do
+    it "should store the new pair in memcache" do
+      @memcache.should_receive(:[]=).with do |key, collection|
+        key.should == Digest::MD5.hexdigest('http://foo.invalid/')
+        collection[@request].should == @response
+      end
+
+      @cache_mngr.store(@request, @response)
+    end 
+  
+    it "should replace existing values if they exist" do
+      entries = Resourceful::CacheEntryCollection.new
+      entries[@request] = @response
+      @memcache.stub!(:[]=).and_return(entries)
+
+      new_request = Resourceful::Request.new(:get, @resource)
+      new_response = Resourceful::Response.new('http://foo.invalid/', '200', {}, "a different body")
+
+      @memcache.should_receive(:[]=).with do |key, collection|
+        collection[new_request].should == new_response
+      end
+      
+      @cache_mngr.store(new_request, new_response)
+    end 
+
+    it "should not store responses that are not cacheable" do
+      @memcache.should_not_receive(:[]=)
+
+      vary_star_response = Resourceful::Response.new('http://foo.invalid/', '200', {'Vary' => '*'}, "a different body")
+ 
+      @cache_mngr.store(@request, vary_star_response)     
+    end 
+  end 
+
+  describe "#lookup" do
+    before do
+      @entries = Resourceful::CacheEntryCollection.new
+      @entries[@request] = @response
+      @memcache.stub!(:get).and_return(@entries)
+    end
+    
+    it "should lookup the entry collection by the URI" do
+      @memcache.should_receive(:get).with(Digest::MD5.hexdigest('http://foo.invalid/')).and_return(@entries)
+
+      @cache_mngr.lookup(@request)
+    end
+ 
+    it "should retrieve responses that match request" do
+      @cache_mngr.lookup(Resourceful::Request.new(:get, @resource)).should == @response
+    end 
+
+    it "should return nil if no responses that match request are found" do
+      @cache_mngr.lookup(Resourceful::Request.new(:get, @resource, "body", {'Accept' => 'text/plain'})).
+        should be_nil
+    end 
+
+    it "should return nil if no responses that resource are found" do
+      @memcache.stub!(:get).and_return(nil)
+
+      @cache_mngr.lookup(Resourceful::Request.new(:get, @resource)).should be_nil
+    end 
+  end 
+
+  describe "#invalidate(url)" do
+    it "should remove all cached responses for that resource from memcache" do
+      @memcache.should_receive(:delete).with(Digest::MD5.hexdigest('http://foo.invalid/'))
+
+      @cache_mngr.invalidate('http://foo.invalid/')
+    end 
+  end 
+end 
+
+describe Resourceful::MemcacheCacheManager, 'init' do 
+  it 'should be createable with single memcache server' do
+    MemCache.should_receive(:new).with(['foobar:42'], anything)
+    
+    Resourceful::MemcacheCacheManager.new('foobar:42')
+  end 
+
+  it 'should be createable with multiple memcache servers' do
+    MemCache.should_receive(:new).with(['foobar:42', 'baz:32'], anything)
+    
+    Resourceful::MemcacheCacheManager.new('foobar:42', 'baz:32')
+  end 
+
+  it 'should create a thread safe memcache client' do
+    MemCache.should_receive(:new).with(anything, {:multithread => true})
+    
+    Resourceful::MemcacheCacheManager.new('foobar:42')
+  end 
+end
+

data/spec/resourceful/options_interpreter_spec.rb

@@ -62,7 +62,15 @@ describe Resourceful::OptionsInterpreter, '#interpret(options)' do
     @interpreter.interpret({}).keys.should_not include(:foo)
   end 
 
-  it 'should not invoked option value munging block if option is not specified'
+  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()