resourceful 0.3.1 → 0.5.0

data/spec/resourceful/response_spec.rb

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

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

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