paul-resourceful 0.2.3

data/spec/resourceful/response_spec.rb

@@ -0,0 +1,238 @@
+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 
+
+  describe '#is_unsuccesful?' do
+    it 'should be true for a 4xx series response code' do
+      Resourceful::Response.new(@uri, 404, {}, "").is_unsuccesful?.should == true
+    end
+
+    it 'should be true for a 5xx series response code' do
+      Resourceful::Response.new(@uri, 500, {}, "").is_unsuccesful?.should == true
+    end
+
+    it 'should be not true for a 2xx series response code' do
+      Resourceful::Response.new(@uri, 200, {}, "").is_unsuccesful?.should == false
+    end
+
+    it 'should be true for a 3xx series response code' do
+      Resourceful::Response.new(@uri, 302, {}, "").is_unsuccesful?.should == true
+    end
+  end
+
+  describe '#is_client_error?' do
+    it 'be true for a 4xx series response code' do
+      Resourceful::Response.new(@uri, 404, {}, "").is_client_error?.should == true
+    end
+
+    it 'be false for anything else' do
+      Resourceful::Response.new(@uri, 200, {}, "").is_client_error?.should == false
+    end
+  end
+
+  describe '#is_server_error?' do
+    it 'be true for a 5xx series response code' do
+      Resourceful::Response.new(@uri, 500, {}, "").is_server_error?.should == true
+    end
+
+    it 'be false for anything else' do
+      Resourceful::Response.new(@uri, 200, {}, "").is_server_error?.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,160 @@
+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 query 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
+
+# Echos the request header in the response body
+EchoHeaderResponder = lambda do |env|
+  body = [env.inspect]
+
+  header = {
+            'Content-Type' => 'text/plain', 
+            'Content-Length' => body.join.size.to_s
+           }
+
+  [ 200, header, body ]
+end unless defined? EchoHeaderResponder
+
+# 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
+    require 'rack'
+    require 'mongrel'
+
+    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( '/echo_header' ){ run EchoHeaderResponder }
+      map( '/modified' ){ run ModifiedResponder }
+      map( '/auth'     ){ run AuthorizationResponder }
+    end
+
+    #spawn the server in a separate thread
+    @httpd = Thread.new do
+      Rack::Handler::Mongrel.run(app, :Host => '127.0.0.1', :Port => 3000)
+    end
+    #give the server a chance to initialize
+    sleep 0.05
+  end
+
+  after(:all) do
+    # kill the server thread
+    @httpd.exit
+  end
+
+
+end