resourceful 0.2

data/spec/resourceful/response_spec.rb

@@ -0,0 +1,199 @@
+require 'pathname'
+require Pathname(__FILE__).dirname + '../spec_helper'
+
+require 'resourceful/response'
+
+describe Resourceful::Response do
+  before do
+    @net_http = mock('net_http')
+    Net::HTTP::Get.stub!(:new).and_return(@net_http)
+    @uri = 'http://www.example.com'
+
+    @response = Resourceful::Response.new(@uri, 0, {}, "")
+  end
+
+  describe 'init' do
+
+    it 'should be instantiatable' do
+      @response.should be_instance_of(Resourceful::Response)
+    end
+
+    it 'should take a [uri, code, header, body] array' do
+      r = Resourceful::Response.new(@uri, 200, {}, "")
+      r.code.should   == 200
+      r.header.should == {}
+      r.body.should   == ""
+    end
+
+  end
+
+  it 'should have a code' do
+    @response.should respond_to(:code)
+  end
+
+  it 'should have a header' do
+    @response.should respond_to(:header)
+  end
+
+  it 'should have header aliased as headers' do
+    @response.should respond_to(:headers)
+    @response.headers.should == @response.header
+  end
+
+  describe "#is_success?" do
+    it 'should be true for 200' do
+      Resourceful::Response.new(@uri, 200, {}, "").is_success?.should == true
+    end 
+
+    it 'should be true for any 2xx' do
+      Resourceful::Response.new(@uri, 299, {}, "").is_success?.should == true
+    end 
+
+    it 'should not be true for 300' do
+      Resourceful::Response.new(@uri, 300, {}, "").is_success?.should == false
+    end 
+
+    it 'should not be true for 199' do
+      Resourceful::Response.new(@uri, 199, {}, "").is_success?.should == false
+    end 
+  end 
+
+  it 'should know if it is a redirect' do
+    Resourceful::Response.new(@uri, 301, {}, "").is_redirect?.should == true
+    Resourceful::Response.new(@uri, 302, {}, "").is_redirect?.should == true
+    Resourceful::Response.new(@uri, 303, {}, "").is_redirect?.should == true
+    Resourceful::Response.new(@uri, 307, {}, "").is_redirect?.should == true
+
+    #aliased as was_redirect?
+    Resourceful::Response.new(@uri, 301, {}, "").was_redirect?.should == true
+  end
+
+  it 'should know if it is a permanent redirect' do
+    Resourceful::Response.new(@uri, 301, {}, "").is_permanent_redirect?.should == true
+  end
+
+  it 'should know if it is a temporary redirect' do
+    Resourceful::Response.new(@uri, 303, {}, "").is_temporary_redirect?.should == true
+  end
+
+  it 'should know if its authoritative' do
+    @response.should respond_to(:authoritative?)
+  end
+
+  it 'should allow authoritative to be set' do
+    @response.authoritative = true
+    @response.authoritative?.should be_true
+  end
+
+  it 'should know if it is authorized' do
+    @response.should respond_to(:is_not_authorized?)
+    Resourceful::Response.new(@uri, 200, {}, "").is_not_authorized?.should == false
+    Resourceful::Response.new(@uri, 401, {}, "").is_not_authorized?.should == true
+  end
+
+  describe 'caching and expiration' do
+    before do
+      Time.stub!(:now).and_return(Time.utc(2008,5,15,18,0,1), Time.utc(2008,5,15,20,0,0))
+
+      @response = Resourceful::Response.new(@uri, 0, {'Date' => ['Thu, 15 May 2008 18:00:00 GMT']}, "")
+      @response.request_time = Time.utc(2008,5,15,17,59,59)
+    end
+
+    it 'should know if its #stale?' do
+      @response.should respond_to(:stale?)
+    end
+
+    it 'should be stale if it is expired' do
+      @response.should_receive(:expired?).and_return(true)
+      @response.should be_stale
+    end
+
+    it 'should know if its #expired?' do
+      @response.should respond_to(:expired?)
+    end
+
+    it 'should be expired if Now is after the "Expire" header' do
+      Time.stub!(:now).and_return(Time.utc(2008,5,23,18,0))
+      @response.header['Expire'] = [(Time.now - 60*60).httpdate]
+
+      @response.should be_expired
+    end
+
+    it 'should have a #current_age' do
+      @response.should respond_to(:current_age)
+    end
+
+    it 'should calculate the #current_age' do
+      @response.current_age.should == (2 * 60 * 60 + 2)
+    end
+      
+    it 'should know if its #cachable?' do
+      @response.should respond_to(:cachable?)
+    end
+
+    it 'should normally be cachable' do
+      @response.cachable?.should be_true
+    end
+
+    def response_with_header(header = {})
+      Resourceful::Response.new(@uri, 200, header, "")
+    end
+
+    it 'should not be cachable if the vary header has "*"' do
+      r = response_with_header('Vary' => ['*'])
+      r.cachable?.should be_false
+    end
+
+    it 'should not be cachable if the Cache-Control header is set to no-store' do
+      r = response_with_header('Cache-Control' => ['no-store'])
+      r.cachable?.should be_false
+    end
+
+    it 'should be stale if the Cache-Control header is set to must-revalidate' do
+      r = response_with_header('Cache-Control' => ['must-revalidate'])
+      r.should be_stale
+    end
+      
+    it 'should be stale if the Cache-Control header is set to no-cache' do
+      r = response_with_header('Cache-Control' => ['no-cache'])
+      r.should be_stale
+    end
+  end
+
+
+  describe '#body' do 
+    it 'should have a body method' do
+      @response.should respond_to(:body)
+    end
+    
+    require 'zlib'
+    ['gzip', ' gzip', ' gzip ', 'GZIP', 'gzIP'].each do |gzip|
+      it "ungzip the body if content-encoding header field is #{gzip}" do
+        compressed_date = StringIO.new.tap do |out|
+          Zlib::GzipWriter.new(out).tap do |zout|
+            zout << "This is a test"
+            zout.close
+          end
+        end.string
+
+        @response = Resourceful::Response.new(@uri, 0, {'Content-Encoding' => [gzip]}, compressed_date)
+
+        @response.body.should == "This is a test"
+      end
+    end
+
+    it 'should leave body unmolested if Content-Encoding missing' do
+      @response = Resourceful::Response.new(@uri, 0, {}, "This is a test")
+      @response.body.should == "This is a test"      
+    end 
+
+    it 'should raise error if Content-Encoding is not supported' do
+      @response = Resourceful::Response.new(@uri, 0, {'Content-Encoding' => ['broken-identity']}, "This is a test")
+      lambda {
+        @response.body 
+      }.should raise_error(Resourceful::UnsupportedContentCoding)
+    end 
+  end
+
+end
+

data/spec/resourceful/stubbed_resource_proxy_spec.rb

@@ -0,0 +1,58 @@
+require 'pathname'
+require Pathname(__FILE__).dirname + '../spec_helper'
+
+require 'resourceful/stubbed_resource_proxy'
+
+describe Resourceful::StubbedResourceProxy, "init" do
+  it 'should require real resource' do
+    lambda{
+      Resourceful::StubbedResourceProxy.new
+    }.should raise_error(ArgumentError)
+  end 
+  
+  it 'should require canned responses hash' do
+    lambda{
+      Resourceful::StubbedResourceProxy.new(stub('resource'))
+    }.should raise_error(ArgumentError)    
+  end 
+  
+  it 'should be creatable with a Resource and canned responses' do
+    Resourceful::StubbedResourceProxy.new(stub('resource'), {})
+  end 
+end 
+
+describe Resourceful::StubbedResourceProxy do
+  before do
+    @resource = stub('resource', :effective_uri => "http://test.invalid/foo")
+    @stubbed_resource = Resourceful::StubbedResourceProxy.
+      new(@resource, [{:mime_type => 'application/xml', 
+                        :body => '<thing>1</thing>'}])
+  end
+  
+  it 'should return canned response body for matching requests' do
+    resp = @stubbed_resource.get
+    resp.body.should == '<thing>1</thing>'
+    resp['content-type'].should == 'application/xml'
+  end 
+  
+  it 'should pass #get() through to base resource if no matching canned response is defined' do
+    @resource.should_receive(:get)
+    @stubbed_resource.get(:accept => 'application/unknown')
+  end 
+
+  it 'should pass #post() through to base resource if no canned response is defined' do
+    @resource.should_receive(:post)
+    @stubbed_resource.post
+  end 
+
+  it 'should pass #put() through to base resource if no canned response is defined' do
+    @resource.should_receive(:put)
+    @stubbed_resource.put
+  end 
+  
+    it 'should pass #effective_uri() through to base resource if no canned response is defined' do
+    @resource.should_receive(:effective_uri)
+    @stubbed_resource.effective_uri
+  end 
+
+end 

data/spec/simple_http_server_shared_spec.rb

@@ -0,0 +1,151 @@
+require 'yaml'
+
+# this sets up a very simple http server using thin to be used in specs.
+SimpleGet = lambda do |env|
+  body = ["Hello, world!"]
+  [ 200, {'Content-Type' => 'text/plain', 'Content-Length' => body.join.size.to_s}, body ]
+end unless defined? SimpleGet
+
+SimplePost = lambda do |env|
+  body = [env['rack.input'].string]
+  [ 201, {'Content-Type' => 'text/plain', 'Content-Length' => body.join.size.to_s}, body ]
+end unless defined? SimplePost
+
+SimplePut = lambda do |env|
+  body = [env['rack.input'].string]
+  [ 200, {'Content-Type' => 'text/plain', 'Content-Length' => body.join.size.to_s}, body ]
+end unless defined? SimplePut
+
+SimpleDel = lambda do |env|
+  body = ["KABOOM!"]
+  [ 200, {'Content-Type' => 'text/plain', 'Content-Length' => body.join.size.to_s}, body ]
+end unless defined? SimpleDel
+
+# has the method used in the body of the response
+MethodResponder = lambda do |env|
+  body = [env['REQUEST_METHOD']]
+  [ 200, {'Content-Type' => 'text/plain', 'Content-Length' => body.join.size.to_s}, body ]
+end unless defined? MethodResponder
+
+# has a response code of whatever it was given in the url /code/{123}
+CodeResponder = lambda do |env|
+  code = env['PATH_INFO'] =~ /([\d]+)/ ? Integer($1) : 404
+  body = [code.to_s]
+
+  [ code, {'Content-Type' => 'text/plain', 'Content-Length' => body.join.size.to_s}, body ]
+end unless defined? CodeResponder
+
+# YAML-parses the quesy string (expected hash) and sets the header to that
+HeaderResponder = lambda do |env|
+  header = YAML.load(URI.unescape(env['QUERY_STRING']))
+  body = [header.inspect]
+
+  header.merge!({
+            'Content-Type' => 'text/plain', 
+            'Content-Length' => body.join.size.to_s
+           })
+
+  [ 200, header, body ]
+end unless defined? HeaderResponder
+
+# redirect. /redirect/{301|302}?{url}
+Redirector = lambda do |env|
+  code = env['PATH_INFO'] =~ /([\d]+)/ ? Integer($1) : 404
+  location = env['QUERY_STRING']
+  body = [location]
+
+  [ code, {'Content-Type' => 'text/plain', 'Location' => location, 'Content-Length' => body.join.size.to_s}, body ]
+end unless defined? Redirector
+
+# Returns 304 if 'If-Modified-Since' is after given mod time
+ModifiedResponder = lambda do |env|
+  modtime = Time.httpdate(URI.unescape(env['QUERY_STRING']))
+
+  code = 200
+  if env['HTTP_IF_MODIFIED_SINCE']
+    code = 304
+  end
+  body = [modtime.to_s]
+
+  header = {'Content-Type' => 'text/plain',
+            'Content-Length' => body.join.size.to_s,
+            'Last-Modified' => modtime.httpdate,
+            'Cache-Control' => 'must-revalidate'}
+
+  [ code, header, body ]
+end unless defined? ModifiedResponder
+
+require 'rubygems'
+require 'httpauth'
+AuthorizationResponder = lambda do |env|
+  authtype = env['QUERY_STRING']
+  header = {}
+  if auth_string = env['HTTP_AUTHORIZATION']
+    if authtype == "basic" &&
+       ['admin', 'secret'] == HTTPAuth::Basic.unpack_authorization(auth_string)
+      code = 200
+      body = ["Authorized"]
+    elsif authtype == "digest" #&&
+          credentials = HTTPAuth::Digest::Credentials.from_header(auth_string) &&
+          credentials &&
+          credentials.validate(:password => 'secret', :method => 'GET')
+      code = 200
+      body = ["Authorized"]
+    else
+      code = 401
+      body = ["Not Authorized"]
+    end
+  else 
+    code = 401
+    body = ["Not Authorized"]
+    if authtype == "basic"
+      header = {'WWW-Authenticate' => HTTPAuth::Basic.pack_challenge('Test Auth')}
+    elsif authtype == "digest"
+      chal = HTTPAuth::Digest::Credentials.new(:realm => 'Test Auth', :qop => 'auth')
+      header = {'WWW-Authenticate' => chal.to_header}
+    end
+  end
+
+  [ code, header.merge({'Content-Type' => 'text/plain', 'Content-Length' => body.join.size.to_s}), body ]
+end unless defined? AuthorizationResponder
+
+describe 'simple http server', :shared => true do
+  before(:all) do
+    #setup a thin http server we can connect to
+    require 'thin'
+    require 'rack'
+    require 'rack/lobster'
+
+    app = Rack::Builder.new do |env|
+      use Rack::ShowExceptions
+
+      map( '/get'    ){ run SimpleGet  }
+      map( '/post'   ){ run SimplePost }
+      map( '/put'    ){ run SimplePut  }
+      map( '/delete' ){ run SimpleDel  }
+
+      map( '/method'   ){ run MethodResponder }
+      map( '/code'     ){ run CodeResponder }
+      map( '/redirect' ){ run Redirector }
+      map( '/header'   ){ run HeaderResponder }
+      map( '/modified' ){ run ModifiedResponder }
+      map( '/auth'     ){ run AuthorizationResponder }
+    end
+
+    #spawn the server in a separate thread
+    @httpd = Thread.new do
+      Thin::Logging.silent = true
+      #Thin::Logging.debug = true
+      Thin::Server.start(app) 
+    end
+    #give the server a chance to initialize
+    sleep 0.05
+  end
+
+  after(:all) do
+    # kill the server thread
+    @httpd.exit
+  end
+
+
+end

data/spec/simple_http_server_shared_spec_spec.rb

@@ -0,0 +1,195 @@
+require 'pathname'
+require Pathname(__FILE__).dirname + 'spec_helper'
+require 'rubygems'
+require 'addressable/uri'
+
+require 'resourceful/net_http_adapter'
+
+describe 'http server' do
+  it_should_behave_like 'simple http server'
+
+  it 'should have a response code of 200 if the path is /get' do
+    Resourceful::NetHttpAdapter.make_request(:get, 'http://localhost:3000/get')[0].should == 200
+  end
+
+  it 'should reply with the posted document in the body if the path is /post' do
+    resp = Resourceful::NetHttpAdapter.make_request(:get, 'http://localhost:3000/post', 'Hello from POST!')
+    resp[2].should == 'Hello from POST!'
+    resp[0].should == 201
+  end
+
+  it 'should reply with the puted document in the body if the path is /put' do
+    resp = Resourceful::NetHttpAdapter.make_request(:put, 'http://localhost:3000/put', 'Hello from PUT!')
+    resp[2].should == 'Hello from PUT!'
+    resp[0].should == 200
+  end
+
+  it 'should reply with "KABOOM!" in the body if the path is /delete' do
+    resp = Resourceful::NetHttpAdapter.make_request(:delete, 'http://localhost:3000/delete')
+    resp[2].should == 'KABOOM!'
+    resp[0].should == 200
+  end
+
+  it 'should have a response code of whatever the path is' do
+    Resourceful::NetHttpAdapter.make_request(:get, 'http://localhost:3000/code/304')[0].should == 304
+  end
+
+  it 'should redirect to a given url' do
+    resp = Resourceful::NetHttpAdapter.make_request(:get, 'http://localhost:3000/redirect/301?http://localhost:3000/get')
+
+    resp[0].should == 301
+    resp[1]['Location'].should == ['http://localhost:3000/get']
+  end
+
+  it 'should respond with the request method in the body' do
+    resp = Resourceful::NetHttpAdapter.make_request(:delete, 'http://localhost:3000/method')
+
+    resp[0].should == 200
+    resp[2].should == "DELETE"
+  end
+
+  it 'should respond with the header set from the query string' do
+    uri = URI.escape('http://localhost:3000/header?{Foo: "bar"}')
+    resp = Resourceful::NetHttpAdapter.make_request(:get, uri)
+
+    resp[1].should have_key('Foo')
+    resp[1]['Foo'].should == ['bar']
+  end
+
+  it 'should parse escaped uris properly' do
+    uri = URI.escape("http://localhost:3000/header?{Expire: \"#{Time.now.httpdate}\"}")
+
+    resp = Resourceful::NetHttpAdapter.make_request(:get, uri)
+
+    resp[1].should have_key('Expire')
+    resp[1]['Expire'].first.should_not =~ /%/
+  end
+
+  describe '/modified' do
+    it 'should be 200 if no I-M-S header' do
+      uri = URI.escape("http://localhost:3000/modified?#{(Time.now + 3600).httpdate}")
+
+      resp = Resourceful::NetHttpAdapter.make_request(:get, uri)
+
+      resp[0].should == 200
+    end
+
+    it 'should be 304 if I-M-S header is set' do
+      now = Time.utc(2008,5,29,12,00)
+      uri = URI.escape("http://localhost:3000/modified?#{(now + 3600).httpdate}")
+
+      resp = Resourceful::NetHttpAdapter.make_request(:get, uri, nil, {'If-Modified-Since' => now.httpdate})
+
+      resp[0].should == 304
+    end
+
+  end
+
+  describe '/auth' do
+    before do
+      @uri = "http://localhost:3000/auth?basic"
+    end
+
+    it 'should return a 401 if no auth info is provided' do
+      resp = Resourceful::NetHttpAdapter.make_request(:get, @uri)
+      resp[0].should == 401
+    end
+
+    describe 'basic' do
+      before do
+        @uri = "http://localhost:3000/auth?basic"
+      end
+
+      it 'should return a 401 if no auth info is provided' do
+        resp = Resourceful::NetHttpAdapter.make_request(:get, @uri)
+        resp[0].should == 401
+      end
+
+      it 'should provide a WWW-Authenticate header when 401' do
+        resp = Resourceful::NetHttpAdapter.make_request(:get, @uri)
+        header = resp[1]
+        header.should have_key('WWW-Authenticate')
+      end
+
+      it 'should set the scheme to "Basic"' do
+        resp = Resourceful::NetHttpAdapter.make_request(:get, @uri)
+        auth = resp[1]['WWW-Authenticate'].first
+        auth.should =~ /^Basic/
+      end
+
+      it 'should set the realm to "Test Auth"' do
+        resp = Resourceful::NetHttpAdapter.make_request(:get, @uri)
+        auth = resp[1]['WWW-Authenticate'].first
+        auth.should =~ /realm="Test Auth"/
+      end
+
+      it 'should authorize on u/p:admin/secret' do
+        creds = HTTPAuth::Basic.pack_authorization('admin', 'secret')
+        header = {'Authorization' => creds}
+        resp = Resourceful::NetHttpAdapter.make_request(:get, @uri, nil, header)
+        resp[0].should == 200
+      end
+
+      it 'should authorize if u/p is incorrect' do
+        creds = HTTPAuth::Basic.pack_authorization('admin', 'not secret')
+        header = {'Authorization' => creds}
+        resp = Resourceful::NetHttpAdapter.make_request(:get, @uri, nil, header)
+        resp[0].should == 401
+      end
+
+    end
+
+    describe 'digest' do
+      before do
+        @uri = "http://localhost:3000/auth?digest"
+      end
+
+      it 'should return a 401 if no auth info is provided' do
+        resp = Resourceful::NetHttpAdapter.make_request(:get, @uri)
+        resp[0].should == 401
+      end
+
+      it 'should provide a WWW-Authenticate header when 401' do
+        resp = Resourceful::NetHttpAdapter.make_request(:get, @uri)
+        header = resp[1]
+        header.should have_key('WWW-Authenticate')
+      end
+
+      it 'should set the scheme to "Digest"' do
+        resp = Resourceful::NetHttpAdapter.make_request(:get, @uri)
+        auth = resp[1]['WWW-Authenticate'].first
+        auth.should =~ /^Digest/
+      end
+
+      it 'should set the realm to "Test Auth"' do
+        resp = Resourceful::NetHttpAdapter.make_request(:get, @uri)
+        auth = resp[1]['WWW-Authenticate'].first
+        auth.should =~ /realm="Test Auth"/
+      end
+
+      def challenge
+        resp = Resourceful::NetHttpAdapter.make_request(:get, @uri)
+        HTTPAuth::Digest::Challenge.from_header(resp[1]['WWW-Authenticate'].first)
+      end
+
+      it 'should authorize on u/p:admin/secret' do
+        creds = HTTPAuth::Digest::Credentials.from_challenge(challenge, :username => 'admin', :password => 'secret', :uri => @uri)
+        header = {'Authorization' => creds.to_header}
+        resp = Resourceful::NetHttpAdapter.make_request(:get, @uri, nil, header)
+        resp[0].should == 200
+      end
+
+      it 'should not authorize if u/p is incorrect' do
+        pending
+        creds = HTTPAuth::Digest::Credentials.from_challenge(challenge, :username => 'admin', :password => 'not secret', :uri => @uri)
+        header = {'Authorization' => creds.to_header}
+        resp = Resourceful::NetHttpAdapter.make_request(:get, @uri, nil, header)
+        resp[0].should == 401
+      end
+
+    end
+
+  end
+
+end
+