resourceful 0.3.1 → 0.5.0

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
-

data/spec/resourceful/net_http_adapter_spec.rb

@@ -1,96 +0,0 @@
-require 'pathname'
-require Pathname(__FILE__).dirname + '../spec_helper'
-
-require 'resourceful/net_http_adapter'
-
-describe Resourceful::NetHttpAdapter do
-  describe '#make_request (mocked)' do
-    it 'should enable ssl on the connection' do
-      resp = stub('http_response', :code => 200, :header => {}, :body => "hello")
-      conn = stub('http_conn', :request => resp, :finish => nil)
-      Net::HTTP.should_receive(:new).and_return(conn)
-      conn.should_receive(:use_ssl=).with(true).ordered
-      conn.should_receive(:start).ordered
-
-      Resourceful::NetHttpAdapter.make_request(:get, 'https://localhost:3000/get')
-    end
-  end
-end
-
-describe Resourceful::NetHttpAdapter do
-  it_should_behave_like 'simple http server'
-
-
-  describe '#make_request' do
-    before do
-      @response = Resourceful::NetHttpAdapter.make_request(:get, 'http://localhost:3000/get')
-    end
-    
-    describe 'response' do
-      it 'should be an array' do
-        @response.should be_instance_of(Array)
-      end
-
-      it 'should have the numeric response code as the first element' do
-        code = @response[0]
-        code.should be_instance_of(Fixnum)
-        code.should == 200
-      end
-
-      it 'should have the Header as the second element' do
-        header = @response[1]
-        header.should be_instance_of(Resourceful::Header)
-        header['content-type'].should == ['text/plain']
-      end
-
-      it 'should have the body as the third and last element' do
-        body = @response[2]
-        body.should == "Hello, world!"
-      end
-
-    end
-
-  end
-
-  describe '#net_http_request_class' do
-
-    it 'should provide Net::HTTP::Get for a get method' do
-      Resourceful::NetHttpAdapter.send(:net_http_request_class, :get).should == Net::HTTP::Get
-    end
-
-    it 'should provide Net::HTTP::Post for a post method' do
-      Resourceful::NetHttpAdapter.send(:net_http_request_class, :post).should == Net::HTTP::Post
-    end
-
-    it 'should provide Net::HTTP::Put for a put method' do
-      Resourceful::NetHttpAdapter.send(:net_http_request_class, :put).should == Net::HTTP::Put
-    end
-
-    it 'should provide Net::HTTP::Delete for a delete method' do
-      Resourceful::NetHttpAdapter.send(:net_http_request_class, :delete).should == Net::HTTP::Delete
-    end
-
-  end
-
-end
-
-describe Addressable::URI, '#absolute_path monkey patch' do
-
-  it 'should have the path and any query parameters' do
-    uri = Addressable::URI.parse('http://localhost/foo?bar=baz')
-    uri.absolute_path.should == '/foo?bar=baz'
-  end
-
-  it 'should not have a ? if there are no query params' do
-    uri = Addressable::URI.parse('http://localhost/foo')
-    uri.absolute_path.should_not =~ /\?/
-    uri.absolute_path.should == '/foo'
-  end
-
-  it 'should not add the query parameter twice' do
-    uri = Addressable::URI.parse('http://localhost/foo?bar=baz')
-    uri.absolute_path.should == '/foo?bar=baz'
-    uri.absolute_path.should == '/foo?bar=baz'
-  end
-
-end

data/spec/resourceful/options_interpreter_spec.rb

@@ -1,102 +0,0 @@
-require File.dirname(__FILE__) + "/../spec_helper"
-require 'resourceful/options_interpreter'
-
-describe Resourceful::OptionsInterpreter, '#initialize' do
-  it 'should be creatable block' do
-    Resourceful::OptionsInterpreter.new() {}
-  end 
-end 
-
-
-describe Resourceful::OptionsInterpreter, "#option()" do
-  before do
-    @interpreter = Resourceful::OptionsInterpreter.new()
-  end
-  
-  it 'should take option name' do
-    @interpreter.option(:test)
-    @interpreter.supported_options.should include(:test)
-  end 
-
-  it 'should take interpretation block' do
-    @interpreter.option(:test) {"this"}
-    @interpreter.supported_options.should include(:test)
-  end 
-end 
-
-describe Resourceful::OptionsInterpreter, '#interpret(options)' do
-  before do
-    @interpreter = Resourceful::OptionsInterpreter.new()
-    @interpreter.option(:foo)
-  end
-  
-  it 'should return hash like structure of interpreted options' do
-    opts = @interpreter.interpret(:foo => 'bar')
-    
-    opts.should have_key(:foo)
-    opts[:foo].should == 'bar'
-  end 
-  
-  it 'should raise argument error if there is an unsupported option in src hash' do
-    lambda {
-      @interpreter.interpret(:bar => 'baz')
-    }.should raise_error(ArgumentError, "Unrecognized options: bar")
-  end
-
-  it 'should list all unsupported options in the exception' do
-    lambda {
-      @interpreter.interpret(:bar => 'baz', :baz => 'bar')
-    }.should raise_error(ArgumentError, /Unrecognized options: (bar, baz)|(baz, bar)/)
-  end
-
-  it 'should execute pass the options though the appropriate handling block' do
-    @interpreter.option(:foo) {|foo| foo + " hello"}
-    
-    @interpreter.interpret(:foo => 'bar')[:foo].should == 'bar hello'
-  end 
-  
-  it 'should not include options that were not passed in resulting hash' do
-    @interpreter = Resourceful::OptionsInterpreter.new()
-    @interpreter.option(:foo)
-    
-    @interpreter.interpret({}).keys.should_not include(:foo)
-  end 
-
-  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()
-    @interpreter.option(:foo, :default => 'hello')
-
-    opts = @interpreter.interpret({})
-    opts.should have_key(:foo)
-    opts[:foo].should == 'hello'
-  end 
-
-  it 'should use default value if option is specified as nil' do
-    @interpreter = Resourceful::OptionsInterpreter.new()
-    @interpreter.option(:foo, :default => 'hello')
-
-    opts = @interpreter.interpret({:foo => nil})
-    opts.should have_key(:foo)
-    opts[:foo].should == 'hello'
-  end 
-
-  it 'should not use default if option is specified ' do
-    @interpreter = Resourceful::OptionsInterpreter.new()
-    @interpreter.option(:foo, :default => 'hello')
-
-    opts = @interpreter.interpret({:foo => 'bye'})
-    opts.should have_key(:foo)
-    opts[:foo].should == 'bye'
-  end 
-
-end