paul-resourceful 0.3.1 → 0.5.0

data/spec/resourceful/cache_manager_spec.rb

@@ -1,223 +0,0 @@
-require 'pathname'
-require Pathname(__FILE__).dirname + '../spec_helper'
-
-require 'resourceful/cache_manager'
- 
-describe Resourceful::AbstractCacheManager do
-  before do
-    @cm = Resourceful::InMemoryCacheManager.new #cheat, because I cant new a real one. 
-  end
-
-  it 'should not be initializable' do
-    lambda { Resourceful::CacheManager.new }.should raise_error
-  end
-
-  it 'should have a lookup method' do
-    @cm.should respond_to(:lookup)
-  end
-
-  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
-end
-
-describe Resourceful::NullCacheManager do
-  before do
-    @ncm = Resourceful::NullCacheManager.new
-  end
-
-  it 'should not find anything' do
-    @ncm.lookup(:stuff).should be_nil
-  end
-
-  it 'should not store anything' 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'),
-                               :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::CacheEntry.stub!(:new).and_return(@entry)
-
-    @imcm = Resourceful::InMemoryCacheManager.new
-  end
-
-  describe 'finding' do
-    before do
-      @response.stub!(:authoritative=)
-      @imcm.instance_variable_set("@collection", {'uri' => {@request => @response}})
-    end
-
-    it 'should lookup the response by request' do
-      @imcm.lookup(@request).should == @response
-    end
-
-    it 'should set the response to non-authoritative' do
-      @response.should_receive(:authoritative=).with(false)
-      @imcm.lookup(@request)
-    end
-  end
-
-  describe 'saving' do
-    it 'should make a new cache entry' do
-      Resourceful::CacheEntry.should_receive(:new).with(
-        @request,
-        @response
-      )
-
-      @imcm.store(@request, @response)
-    end
-
-    it 'should store the response entity by request' do
-      @imcm.store(@request, @response)
-      col = @imcm.instance_variable_get("@collection")
-      col['uri'][@request].should == @response
-    end
-
-    it 'should check if the response is cachable' do
-      @response.should_receive(:cachable?).and_return(true)
-      @imcm.store(@request, @response)
-    end
-
-    it 'should not store an entry if the response is not cachable' do
-      @response.should_receive(:cachable?).and_return(false)
-      @imcm.store(@request, @response)
-      col = @imcm.instance_variable_get("@collection")
-      col['uri'][@request].should be_nil
-    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::CacheEntryCollection do
-  before do
-    @request = mock('request', :uri => 'this', :request_time => Time.now, :header => {})
-    @valid_resp = stub('valid_resp', :authoritative= => nil, :header => {})
-
-    @entry_valid   = mock('entry', :valid_for? => true, :response => @valid_resp)
-    @entry_invalid = mock('entry', :valid_for? => false, :response => stub('invalid_resp'))
-
-    @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 == @valid_resp
-  end
-
-  it 'should be nil if no matching entry was found' do
-    @collection.instance_variable_set('@entries', [@entry_invalid])
-    @entry_invalid.should_receive(:valid_for?).with(@request).and_return(false)
-    @collection[@request].should == nil
-  end
-
-  it 'should store an entry' do
-    @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_resp = stub('new_resp', :authoritative= => nil, :header => {})
-
-    @collection[@request] = @valid_resp
-    @collection[@request] = new_resp
-
-    @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::CacheEntry do
-  before do
-    @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', :uri => 'http://foo.invalid')
-  end
-
-  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
-
-  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')
-      @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/header_spec.rb

@@ -1,38 +0,0 @@
-require 'pathname'
-require Pathname(__FILE__).dirname + '../spec_helper'
-
-require 'resourceful/header'
-
-describe Resourceful::Header do
-
-  it "should capitalize on all accesses" do
-    h = Resourceful::Header.new("foo" => "bar")
-    h["foo"].should == "bar"
-    h["Foo"].should == "bar"
-    h["FOO"].should == "bar"
-
-    h.to_hash.should == {"Foo" => "bar"}
-
-    h["bar-zzle"] = "quux"
-
-    h.to_hash.should == {"Foo" => "bar", "Bar-Zzle" => "quux"}
-  end
-
-  it "should capitalize correctly" do
-    h = Resourceful::Header.new
-
-    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-quux").should == "Foo-Bar-Quux"
-    h.capitalize("foo-bar-2quux").should == "Foo-Bar-2quux"
-  end
-
-  it "should be converted to real Hash" do
-    h = Resourceful::Header.new("foo" => "bar")
-    h.to_hash.should be_instance_of(Hash)
-  end
-
-end
-

data/spec/resourceful/http_accessor_spec.rb

@@ -1,164 +0,0 @@
-require 'pathname'
-require Pathname(__FILE__).dirname + '../spec_helper'
-
-require 'resourceful/http_accessor'
-
-describe Resourceful::HttpAccessor, 'init' do
-    
-  it 'should be instantiatable' do
-    Resourceful::HttpAccessor.new().should be_instance_of(Resourceful::HttpAccessor)
-  end 
-  
-  it 'should accept logger to new' do
-    ha = Resourceful::HttpAccessor.new(:logger => (l = stub('logger')))
-    
-    ha.logger.should == l
-  end 
-
-  it 'should provide logger object even when no logger is specified' do
-    ha = Resourceful::HttpAccessor.new()
-    
-    ha.logger.should be_instance_of(Resourceful::BitBucketLogger)
-  end 
-
-  it 'should raise arg error if unrecognized options are passed' do
-    lambda {
-      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
-    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
-    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 
-
-describe Resourceful::HttpAccessor do 
-  before do
-    @logger = stub('logger')
-    @accessor = Resourceful::HttpAccessor.new(:logger => @logger)
-    @auth_manager = mock('authentication_manager')
-    Resourceful::AuthenticationManager.stub!(:new).and_return(@auth_manager)
-
-    @resource = mock('resource')
-    Resourceful::Resource.stub!(:new).and_return(@resource)
-  end
-  
-  it 'should have user agent string w/ just resourceful token by default' do
-    @accessor.user_agent_string.should == "Resourceful/#{RESOURCEFUL_VERSION}(Ruby/#{RUBY_VERSION})"
-  end 
-  
-  it 'should add additional user agent tokens to beginning of user agent string' do
-    @accessor.user_agent_tokens << 'FooBar/3000(special-version)'
-    
-    @accessor.user_agent_string.should match(%r{^FooBar\/3000\(special-version\) Resourceful/})
-  end
-  
-  it 'should allow a logger to be specified' do
-    l = stub('logger')
-    
-    @accessor.logger = l
-    @accessor.logger.should == l
-  end 
-
-  it 'should allow a logger to be removed' do
-    l = stub('logger')
-    
-    @accessor.logger = l
-    @accessor.logger = nil
-    @accessor.logger.should be_nil    
-  end 
-
-  it 'should be able to return a particular resource (#[])' do
-    @accessor['http://www.example/'].should == @resource
-  end 
-
-  it 'should create resource if it does not already exist (#[])' do
-    Resourceful::Resource.should_receive(:new).and_return(stub('resource'))
-    @accessor['http://www.example/previously-unused-uri']
-  end 
-
-  it 'should pass uri to resource upon creation (#[])' do
-    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, anything).and_return(stub('resource'))
-    @accessor['http://www.example/previously-unused-uri']
-  end 
-
-  it 'should be able to return a particular resource (#resource)' do
-    @accessor.resource('http://www.example/').should == @resource
-  end 
-
-  it 'should create resource if it does not already exist (#resource)' do
-    Resourceful::Resource.should_receive(:new).and_return(stub('resource'))
-    @accessor.resource('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, 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', 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

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