resourceful 0.2

data/spec/resourceful/authentication_manager_spec.rb

@@ -0,0 +1,204 @@
+require 'pathname'
+require Pathname(__FILE__).dirname + '../spec_helper'
+
+require 'resourceful/authentication_manager'
+
+describe Resourceful::AuthenticationManager do
+
+  before do
+    @authmgr = Resourceful::AuthenticationManager.new
+
+    @authenticator = mock('Authenticator')
+  end
+
+  [:add_auth_handler, :associate_auth_info, :add_credentials].each do |meth|
+    it "should have ##{meth}" do
+      @authmgr.should respond_to(meth)
+    end
+  end
+
+  it 'should add an authenticator to its list' do
+    @authmgr.add_auth_handler(@authenticator)
+    @authmgr.instance_variable_get("@authenticators").should include(@authenticator)
+  end
+
+  describe 'associating authenticators with challanges' do
+    before do
+      @authmgr.add_auth_handler(@authenticator)
+      @authenticator.stub!(:valid_for?).and_return(true)
+      @authenticator.stub!(:update_credentials)
+      @challenge = mock('Response')
+    end
+
+    it 'should check that an authenticator is valid for a challenge' do
+      @authenticator.should_receive(:valid_for?).with(@challenge).and_return(true)
+      @authmgr.associate_auth_info(@challenge)
+    end
+   
+    it 'should update the credentials of the authenticator if it is valid for the challenge' do
+      @authenticator.should_receive(:update_credentials).with(@challenge)
+      @authmgr.associate_auth_info(@challenge)
+    end
+
+    it 'should not update the credentials of the authenticator if it is not valid for the challenge' do
+      @authenticator.stub!(:valid_for?).and_return(false)
+      @authenticator.should_not_receive(:update_credentials).with(@challenge)
+      @authmgr.associate_auth_info(@challenge)
+    end
+
+  end 
+
+  describe 'adding credentials to a request' do
+    before do
+      @authmgr.add_auth_handler(@authenticator)
+      @authenticator.stub!(:can_handle?).and_return(true)
+      @authenticator.stub!(:add_credentials_to)
+      @request = mock('Request')
+    end
+
+    it 'should find an authenticator that can handle the request' do
+      @authenticator.should_receive(:can_handle?).with(@request).and_return(true)
+      @authmgr.add_credentials(@request)
+    end
+
+    it 'should add the authenticators credentials to the request' do
+      @authenticator.should_receive(:add_credentials_to).with(@request)
+      @authmgr.add_credentials(@request)
+    end
+
+    it 'should not add the authenticators credentials to the request if it cant handle it' do
+      @authenticator.should_receive(:can_handle?).with(@request).and_return(false)
+      @authenticator.should_not_receive(:add_credentials_to).with(@request)
+      @authmgr.add_credentials(@request)
+    end
+
+  end
+
+end
+
+describe Resourceful::BasicAuthenticator do
+  before do 
+    @auth = Resourceful::BasicAuthenticator.new('Test Auth', 'admin', 'secret')
+  end
+
+  {:realm => 'Test Auth', :username => 'admin', :password => 'secret'}.each do |meth,val|
+    it "should initialize with a #{meth}" do
+      @auth.instance_variable_get("@#{meth}").should == val
+    end
+  end
+
+  describe "Updating from a challenge response" do
+    before do
+      @header = {'WWW-Authenticate' => ['Basic realm="Test Auth"']}
+      @chal = mock('response', :header => @header, :uri => 'http://example.com/foo/bar')
+    end
+
+    it 'should be valid for a challenge response with scheme "Basic" and the same realm' do
+      @auth.valid_for?(@chal).should be_true
+    end
+
+    it 'should be valid for a challenge response with multiple schemes including matchin "Basic" challenge' do
+      @header = {'WWW-Authenticate' => ['Digest some other stuff', 'Basic realm="Test Auth"', 'Weird scheme']}
+
+      @auth.valid_for?(@chal).should be_true
+    end
+
+    it 'should not be sensitive to case variances in the scheme' do
+      @header['WWW-Authenticate'] = ['bAsIc realm="Test Auth"']
+      @auth.valid_for?(@chal).should be_true
+    end
+
+    it 'should not be sensitive to case variances in the realm directive' do
+      @header['WWW-Authenticate'] = ['Basic rEaLm="Test Auth"']
+      @auth.valid_for?(@chal).should be_true
+    end
+
+    it 'should not be sensitive to case variances in the realm value' do
+      @header['WWW-Authenticate'] = ['Basic realm="test auth"']
+      @auth.valid_for?(@chal).should be_true
+    end
+ 
+    it 'should not be valid if the scheme is not "Basic"' do
+      @header['WWW-Authenticate'] = ["Digest"]
+      @auth.valid_for?(@chal).should be_false
+    end
+
+    it 'should not be valid if the realm does not match' do
+      @header['WWW-Authenticate'] = ['Basic realm="not test auth"']
+      @auth.valid_for?(@chal).should be_false
+    end
+
+    it 'should not be valid if the header is unreadable' do
+      @header['WWW-Authenticate'] = nil
+      @auth.valid_for?(@chal).should be_false
+    end
+
+    it 'should set the valid domain from the host part of the challenge uri' do
+      @auth.update_credentials(@chal)
+      @auth.instance_variable_get("@domain").should == 'example.com'
+    end
+
+  end
+  
+  describe 'updating a request with credentials' do
+    before do
+      @auth.instance_variable_set("@domain", 'example.com')
+      @header = {}
+      @req  = mock('request', :uri => 'http://example.com/bar/foo', :header => @header)
+    end
+
+    it 'should be able to handle a request for the matching domain' do
+      @auth.can_handle?(@req).should be_true
+    end
+
+    it 'should add credentials to a request' do
+      @header.should_receive(:[]=).with('Authorization', 'Basic YWRtaW46c2VjcmV0')
+      @auth.add_credentials_to(@req)
+    end
+
+    it 'should build the credentials string for the header' do
+      @auth.credentials.should == 'Basic YWRtaW46c2VjcmV0'
+    end
+  end
+
+end
+
+describe Resourceful::DigestAuthenticator do
+
+  before do 
+    @auth = Resourceful::DigestAuthenticator.new('Test Auth', 'admin', 'secret')
+  end
+
+  {:realm => 'Test Auth', :username => 'admin', :password => 'secret'}.each do |meth,val|
+    it "should initialize with a #{meth}" do
+      @auth.instance_variable_get("@#{meth}").should == val
+    end
+  end
+
+  describe "Updating from a challenge response" do
+    before do
+      @header = {'WWW-Authenticate' => ['Digest realm="Test Auth"']}
+      @chal = mock('response', :header => @header, :uri => 'http://example.com/foo/bar')
+    end
+
+    it 'should be valid for a challenge response with scheme "Digest" and the same realm' do
+      @auth.valid_for?(@chal).should be_true
+    end
+
+    it 'should not be valid if the scheme is not "Digest"' do
+      @header['WWW-Authenticate'] = ["Basic"]
+      @auth.valid_for?(@chal).should be_false
+    end
+
+    it 'should not be valid if the realm does not match' do
+      @header['WWW-Authenticate'] = ['Digest realm="not test auth"']
+      @auth.valid_for?(@chal).should be_false
+    end
+
+    it 'should not be valid if the header is unreadable' do
+      @header['WWW-Authenticate'] = nil
+      @auth.valid_for?(@chal).should be_false
+    end
+  end
+
+end

data/spec/resourceful/cache_manager_spec.rb

@@ -0,0 +1,202 @@
+require 'pathname'
+require Pathname(__FILE__).dirname + '../spec_helper'
+
+require 'resourceful/cache_manager'
+
+describe Resourceful::CacheManager 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
+
+  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
+  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', :uri => 'uri'),
+                               :request_time => Time.utc(2008,5,22,15,00))
+    @response = mock('response', :header => {})
+
+    @entry = mock('cache entry', :response => @response, :valid_for? => true)
+    Resourceful::InMemoryCacheManager::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 => @entry}})
+    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
+    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),
+        {},
+        @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].response.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
+
+end
+
+describe Resourceful::InMemoryCacheManager::CacheEntryCollection do
+  before do
+    @entry_valid   = mock('entry', :valid_for? => true)
+    @entry_invalid = mock('entry', :valid_for? => false)
+
+    @request = mock('request')
+
+    @collection = Resourceful::InMemoryCacheManager::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
+  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] = @entry_valid
+    @collection.instance_variable_get("@entries").should include(@entry_valid)
+  end
+
+  it 'should replace an existing entry if the existing entry matches the request' do
+    @new_entry = mock('entry', :valid_for? => true)
+
+    @collection[@request] = @entry_valid
+    @collection[@request] = @new_entry
+
+    @collection.instance_variable_get("@entries").should include(@new_entry)
+    @collection.instance_variable_get("@entries").should_not include(@entry_valid)
+  end
+
+end
+
+describe Resourceful::InMemoryCacheManager::CacheEntry do
+  before do
+    @entry = Resourceful::InMemoryCacheManager::CacheEntry.new(
+      Time.utc(2008,5,16,0,0,0), {'Content-Type' => 'text/plain'}, mock('response')
+    )
+
+    @request = mock('request')
+  end
+
+  [:request_time, :request_vary_headers, :response, :valid_for?].each do |method|
+    it "should respond to ##{method}" do
+      @entry.should respond_to(method)
+    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
+
+  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
+
+end
+
+

data/spec/resourceful/header_spec.rb

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

@@ -0,0 +1,120 @@
+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::HttpAccessor::BitBucketLogger)
+  end 
+
+  it 'should raise arg error if unrecognized options are passed' do
+    lambda {
+      ha = 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
+  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
+  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').
+      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'))
+    @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).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').
+      and_return(stub('resource'))
+    @accessor.resource('http://www.example/previously-unused-uri')
+  end 
+
+end