paul-resourceful 0.2.3

data/spec/resourceful/authentication_manager_spec.rb

@@ -0,0 +1,249 @@
+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 
+    @header = {'WWW-Authenticate' => ['Digest realm="Test Auth"']}
+    @chal = mock('response', :header => @header, :uri => 'http://example.com/foo/bar')
+
+    @req_header = {}
+    @req = mock('request', :header => @req_header, 
+                           :uri => 'http://example.com',
+                           :method => 'GET')
+
+    @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 credentials from a challenge response" do
+
+    it "should set the domain from the host part of the challenge response uri" do
+      @auth.update_credentials(@chal)
+      @auth.domain.should == 'example.com'
+    end
+
+    it "should create an HTTPAuth Digest Challenge from the challenge response WWW-Authenticate header" do
+      HTTPAuth::Digest::Challenge.should_receive(:from_header).with(@header['WWW-Authenticate'].first)
+      @auth.update_credentials(@chal)
+    end
+
+  end
+
+  describe "Validating a challenge" do
+    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
+
+  it "should be able to handle requests to the same domain" do
+    @auth.instance_variable_set("@domain", 'example.com')
+    @auth.can_handle?(@req).should be_true
+  end
+
+  it "should not handle requests to a different domain" do
+    @auth.instance_variable_set("@domain", 'example2.com')
+    @auth.can_handle?(@req).should be_false
+  end
+
+  it "should add credentials to a request" do
+    @auth.update_credentials(@chal)
+    @auth.add_credentials_to(@req)
+    @req_header.should have_key('Authorization')
+    @req_header['Authorization'].should_not be_blank
+  end
+
+  it "should have HTTPAuth::Digest generate the Authorization header" do
+    @auth.update_credentials(@chal)
+    cred = mock('digest_credentials', :to_header => nil)
+
+    HTTPAuth::Digest::Credentials.should_receive(:from_challenge).with(
+      @auth.challenge, :username => 'admin', :password => 'secret', :method => 'GET', :uri => ''
+    ).and_return(cred)
+
+    cred = @auth.credentials_for(@req)
+  end
+
+end

data/spec/resourceful/cache_manager_spec.rb

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