paul-resourceful 0.2.3

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,125 @@
+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 {
+      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', 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

data/spec/resourceful/net_http_adapter_spec.rb

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

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

data/spec/resourceful/request_spec.rb

@@ -0,0 +1,186 @@
+require 'pathname'
+require Pathname(__FILE__).dirname + '../spec_helper'
+require 'rubygems'
+require 'addressable/uri'
+
+describe Resourceful::Request do
+  before do
+    @uri = Addressable::URI.parse('http://www.example.com')
+    @resource = mock('resource', :logger => Resourceful::BitBucketLogger.new)
+    @resource.stub!(:uri).and_return(@uri)
+
+    @request = Resourceful::Request.new(:get, @resource)
+
+    @cachemgr = mock('cache_mgr')
+    @cachemgr.stub!(:lookup).and_return(nil)
+    @cachemgr.stub!(:store)
+    @resource.stub!(:accessor).and_return(mock('accessor', :cache_manager => @cachemgr, :logger => Resourceful::BitBucketLogger.new))
+  end
+
+  describe 'init' do
+
+    it 'should be instantiatable' do
+      @request.should be_instance_of(Resourceful::Request)
+    end
+
+    it 'should take an http method' do
+      @request.method.should == :get
+    end
+
+    it 'should take a resource' do
+      @request.resource.should == @resource
+    end
+
+    it 'should take an optional body' do
+      req = Resourceful::Request.new(:get, @resource)
+      req.body.should be_nil
+
+      req = Resourceful::Request.new(:post, @resource, 'Hello from post!')
+      req.body.should == 'Hello from post!'
+    end
+
+    it 'should have a request_time' do
+      @request.should respond_to(:request_time)
+    end
+
+  end
+
+  describe '#response' do
+    before do
+      @net_http_adapter_response = mock('net_http_adapter_response')
+      Resourceful::NetHttpAdapter.stub!(:make_request).and_return(@net_http_adapter_response)
+
+      @response = mock('response', :code => 200, :authoritative= => true, :was_unsuccessful? => false, :request_time= => nil)
+      Resourceful::Response.stub!(:new).and_return(@response)
+    end
+
+    it 'should be a method' do
+      @request.should respond_to(:response)
+    end
+
+    it 'should return the Response object' do
+      @request.response.should == @response
+    end
+
+    it 'should set the request_time to now' do
+      now = Time.now
+      Time.stub!(:now).and_return(now)
+
+      @request.response
+      @request.request_time.should == now
+    end
+
+    it 'should set the response\'s request time' do
+      now = Time.now
+      Time.stub!(:now).and_return(now)
+
+      @response.should_receive(:request_time=).with(now)
+      @request.response
+    end
+  end
+
+  describe '#should_be_redirected?' do
+    before do
+      @net_http_adapter_response = mock('net_http_adapter_response')
+      Resourceful::NetHttpAdapter.stub!(:make_request).and_return(@net_http_adapter_response)
+
+      @response = mock('response', :code => 200, :authoritative= => true, :was_unsuccessful? => false, :request_time= => nil)
+      Resourceful::Response.stub!(:new).and_return(@response)
+    end
+
+    describe 'with no callback set' do
+      before do
+        @callback = nil
+        @resource.stub!(:on_redirect).and_return(@callback)
+      end
+
+      it 'should be true for GET' do
+        request = Resourceful::Request.new(:get, @resource, @post_data)
+
+        request.should_be_redirected?.should be_true
+      end
+
+      it 'should be false for POST, etc' do
+        request = Resourceful::Request.new(:post, @resource, @post_data)
+
+        request.should_be_redirected?.should be_false
+      end
+
+    end
+
+    it 'should be true when callback returns true' do
+      @callback = lambda { true }
+      @resource.stub!(:on_redirect).and_return(@callback)
+      request = Resourceful::Request.new(:get, @resource, @post_data)
+
+      request.should_be_redirected?.should be_true
+    end
+
+    it 'should be false when callback returns false' do
+      @callback = lambda { false }
+      @resource.stub!(:on_redirect).and_return(@callback)
+      request = Resourceful::Request.new(:get, @resource, @post_data)
+
+      request.should_be_redirected?.should be_false
+    end
+
+  end 
+
+  describe "content coding" do 
+    it "should set Accept-Encoding automatically" do
+      @request.header['Accept-Encoding'].should == 'gzip, identity'
+    end
+  end
+
+  describe '#set_validation_headers' do
+    before do
+      @cached_response = mock('cached_response')
+
+      @cached_response_header = mock('header', :[] => nil, :has_key? => false)
+      @cached_response.stub!(:header).and_return(@cached_response_header)
+
+      @cachemgr.stub!(:lookup).and_return(@cached_response)
+    end
+
+    it 'should have an #set_validation_headers method' do
+      @request.should respond_to(:set_validation_headers)
+    end
+
+    it 'should set If-None-Match to the cached response\'s ETag' do
+      @cached_response_header.should_receive(:[]).with('ETag').and_return('some etag')
+      @cached_response_header.should_receive(:has_key?).with('ETag').and_return(true)
+      @request.set_validation_headers(@cached_response)
+
+      @request.header['If-None-Match'].should == 'some etag'
+    end
+
+    it 'should not set If-None-Match if the cached response does not have an ETag' do
+      @request.set_validation_headers(@cached_response)
+      @request.header.should_not have_key('If-None-Match')
+    end
+
+    it 'should set If-Modified-Since to the cached response\'s Last-Modified' do
+      @cached_response_header.should_receive(:[]).with('Last-Modified').and_return('some date')
+      @cached_response_header.should_receive(:has_key?).with('Last-Modified').and_return(true)
+      @request.set_validation_headers(@cached_response)
+
+      @request.header['If-Modified-Since'].should == 'some date'
+    end
+
+    it 'should not set If-Modified-Since if the cached response does not have Last-Modified' do
+      @request.set_validation_headers(@cached_response)
+      @request.header.should_not have_key('If-Modified-Since')
+    end
+
+    it 'should add "Cache-Control: max-age=0" to the request when revalidating a response that has "Cache-Control: must-revalidate" set' do
+      @cached_response_header.should_receive(:[]).with('Cache-Control').and_return(['must-revalidate'])
+      @cached_response_header.should_receive(:has_key?).with('Cache-Control').and_return(true)
+      @request.set_validation_headers(@cached_response)
+
+      @request.header['Cache-Control'].should include('max-age=0')
+    end
+
+  end
+
+end
+