resourceful 0.3.1 → 0.5.0

data/spec/spec_helper.rb

@@ -1,14 +1,28 @@
 require 'rubygems'
-require 'pathname'
 require 'spec'
-require 'pp'
-require 'facets'
 
-$LOAD_PATH << Pathname(__FILE__).dirname + "../lib"
-require 'resourceful/util'
+$LOAD_PATH << File.join(File.dirname(__FILE__), "..", "lib")
 require 'resourceful'
-require 'resourceful/http_accessor'
 
-require Pathname(__FILE__).dirname + 'simple_http_server_shared_spec'
+$LOAD_PATH << File.dirname(__FILE__) # ./spec
 
+# Spawn the server in another process
+
+@server = Thread.new do
+
+  require 'simple_sinatra_server'
+  Sinatra::Default.set(
+    :run => true,
+    :logging => false
+  )
+
+end
+
+# Kill the server process when rspec finishes
+at_exit { @server.exit }
+
+
+# Give the app a change to initialize
+$stderr.puts "Waiting for thin to initialize..."
+sleep 0.2
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: resourceful
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.5.0
 platform: ruby
 authors: 
 - Paul Sadauskas
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-05 00:00:00 -07:00
+date: 2009-07-13 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -82,6 +82,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 description: An HTTP library for Ruby that takes advantage of everything HTTP has to offer.
 email: psadauskas@gmail.com
 executables: []
@@ -89,58 +99,56 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- lib/resourceful.rb
-- lib/resourceful/authentication_manager.rb
-- lib/resourceful/util.rb
-- lib/resourceful/resource.rb
-- lib/resourceful/memcache_cache_manager.rb
+- README.markdown
+- lib/resourceful/cache_manager.rb
+- lib/resourceful/exceptions.rb
 - lib/resourceful/net_http_adapter.rb
-- lib/resourceful/http_accessor.rb
 - lib/resourceful/stubbed_resource_proxy.rb
 - lib/resourceful/header.rb
-- lib/resourceful/cache_manager.rb
-- lib/resourceful/options_interpreter.rb
-- lib/resourceful/response.rb
-- lib/resourceful/request.rb
-- README.markdown
-files: 
-- lib/resourceful.rb
 - lib/resourceful/authentication_manager.rb
-- lib/resourceful/util.rb
+- lib/resourceful/request.rb
 - lib/resourceful/resource.rb
+- lib/resourceful/response.rb
+- lib/resourceful/util.rb
+- lib/resourceful/http_accessor.rb
+- lib/resourceful/options_interpreter.rb
 - lib/resourceful/memcache_cache_manager.rb
+- lib/resourceful.rb
+files: 
+- Manifest
+- spec/spec.opts
+- spec/simple_sinatra_server_spec.rb
+- spec/simple_sinatra_server.rb
+- spec/acceptance/header_spec.rb
+- spec/acceptance/caching_spec.rb
+- spec/acceptance/resource_spec.rb
+- spec/acceptance/redirecting_spec.rb
+- spec/acceptance/authorization_spec.rb
+- spec/acceptance_shared_specs.rb
+- spec/spec_helper.rb
+- spec/old_acceptance_specs.rb
+- README.markdown
+- resourceful.gemspec
+- lib/resourceful/cache_manager.rb
+- lib/resourceful/exceptions.rb
 - lib/resourceful/net_http_adapter.rb
-- lib/resourceful/http_accessor.rb
 - lib/resourceful/stubbed_resource_proxy.rb
 - lib/resourceful/header.rb
-- lib/resourceful/cache_manager.rb
-- lib/resourceful/options_interpreter.rb
-- lib/resourceful/response.rb
+- lib/resourceful/authentication_manager.rb
 - lib/resourceful/request.rb
-- spec/acceptance_shared_specs.rb
-- spec/spec.opts
-- spec/acceptance_spec.rb
-- spec/simple_http_server_shared_spec_spec.rb
-- spec/spec_helper.rb
-- spec/resourceful/header_spec.rb
-- spec/resourceful/authentication_manager_spec.rb
-- spec/resourceful/memcache_cache_manager_spec.rb
-- spec/resourceful/response_spec.rb
-- spec/resourceful/options_interpreter_spec.rb
-- spec/resourceful/http_accessor_spec.rb
-- spec/resourceful/stubbed_resource_proxy_spec.rb
-- spec/resourceful/request_spec.rb
-- spec/resourceful/resource_spec.rb
-- spec/resourceful/cache_manager_spec.rb
-- spec/resourceful/net_http_adapter_spec.rb
-- spec/simple_http_server_shared_spec.rb
-- Manifest
+- lib/resourceful/resource.rb
+- lib/resourceful/response.rb
+- lib/resourceful/util.rb
+- lib/resourceful/http_accessor.rb
+- lib/resourceful/options_interpreter.rb
+- lib/resourceful/memcache_cache_manager.rb
+- lib/resourceful.rb
 - Rakefile
-- README.markdown
 - MIT-LICENSE
-- resourceful.gemspec
 has_rdoc: true
 homepage: http://github.com/paul/resourceful
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --line-numbers
@@ -166,9 +174,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: resourceful
-rubygems_version: 1.3.1
+rubygems_version: 1.3.3
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: An HTTP library for Ruby that takes advantage of everything HTTP has to offer.
 test_files: []
 

data/spec/resourceful/authentication_manager_spec.rb

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

@@ -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
-
-