resourceful 0.3.1 → 0.5.0

data/spec/acceptance/header_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'resourceful'
+
+describe Resourceful do
+
+  describe 'setting headers' do
+    before do
+      @http = Resourceful::HttpAccessor.new
+      @resource = @http.resource("http://localhost:3000/header")
+    end
+
+    it 'should handle "Content-Type"' do
+      resp = @resource.post("asdf", :content_type => 'foo/bar')
+
+      header = YAML.load(resp.body)
+
+      header.should have_key('CONTENT_TYPE')
+      header['CONTENT_TYPE'].should == 'foo/bar'
+
+    end
+
+  end
+end
+

data/spec/acceptance/redirecting_spec.rb

@@ -0,0 +1,12 @@
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'resourceful'
+
+describe Resourceful do
+
+  describe "redirects" do
+
+  end
+
+end
+

data/spec/acceptance/resource_spec.rb

@@ -0,0 +1,84 @@
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'resourceful'
+
+describe Resourceful do
+
+  describe "working with a resource" do
+    before do 
+      @http = Resourceful::HttpAccessor.new
+      @resource = @http.resource('http://localhost:3000/')
+    end
+
+    it 'should make the original uri available' do 
+      @resource.effective_uri.should == 'http://localhost:3000/'
+      @resource.uri.should == 'http://localhost:3000/'
+    end
+
+    it 'should set the user agent string on the default header' do
+      @resource.default_header.should have_key('User-Agent')
+      @resource.default_header['User-Agent'].should == Resourceful::RESOURCEFUL_USER_AGENT_TOKEN
+    end
+
+    describe "GET" do
+
+      it "should be performable on a resource and return a response" do
+        response = @resource.get
+        response.should be_kind_of(Resourceful::Response)
+      end
+
+    end
+
+    describe "POST" do
+
+      it "should be performable on a resource and return a response" do
+        response = @resource.post
+        response.should be_kind_of(Resourceful::Response)
+      end
+
+      it "should require Content-Type be set if a body is provided" do
+        lambda {
+          @resource.post("some text")
+        }.should raise_error(Resourceful::MissingContentType)
+      end
+
+    end
+
+    describe "PUT" do
+
+      it "should be performable on a resource and return a response" do
+        response = @resource.put(nil)
+        response.should be_kind_of(Resourceful::Response)
+      end
+
+      it "should require Content-Type be set if a body is provided" do
+        lambda {
+          @resource.put("some text")
+        }.should raise_error(Resourceful::MissingContentType)
+      end
+
+      it "should require an entity-body to be set" do
+        lambda {
+          @resource.put()
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should allow the entity-body to be nil" do
+        lambda {
+          @resource.put(nil)
+        }.should_not raise_error(ArgumentError)
+      end
+    end
+
+    describe "DELETE" do
+
+      it "should be performable on a resource and return a response" do
+        response = @resource.delete
+        response.should be_kind_of(Resourceful::Response)
+      end
+
+    end
+
+    
+  end
+end

data/spec/acceptance_shared_specs.rb

@@ -2,48 +2,43 @@ describe 'redirect', :shared => true do
   it 'should be followed by default on GET' do
     resp = @resource.get
     resp.should be_instance_of(Resourceful::Response)
-    resp.code.should == 200
+    resp.should be_ok
     resp.header['Content-Type'].should == ['text/plain']
   end
 
   %w{PUT POST}.each do |method|
     it "should not be followed by default on #{method}" do
-      lambda {
-        @resource.send(method.downcase.intern, nil, :content_type => 'text/plain' )
-      }.should raise_error(Resourceful::UnsuccessfulHttpRequestError)
+      resp = @resource.send(method.downcase.intern, nil, :content_type => 'text/plain' )
+      resp.should be_redirect
     end
 
     it "should redirect on #{method.to_s.upcase} if the redirection callback returns true" do
       @resource.on_redirect { true }
       resp = @resource.send(method.downcase.intern, nil, :content_type => 'text/plain' )
-      resp.code.should == 200
+      resp.should be_ok
     end
 
-    it "should not redirect on #{method.to_s.upcase} if the redirection callback returns false" do
+    it "should not follow redirect on #{method.to_s.upcase} if the redirection callback returns false" do
       @resource.on_redirect { false }
-      lambda {
-        @resource.send(method.downcase.intern, nil, :content_type => 'text/plain' )
-      }.should raise_error(Resourceful::UnsuccessfulHttpRequestError)
+      resp = @resource.send(method.downcase.intern, nil, :content_type => 'text/plain' )
+      resp.should be_redirect
     end
   end
 
   it "should not be followed by default on DELETE" do
-    lambda {
-      @resource.delete
-    }.should raise_error(Resourceful::UnsuccessfulHttpRequestError)
+    resp = @resource.delete
+    resp.should be_redirect
   end
 
   it "should redirect on DELETE if vthe redirection callback returns true" do
     @resource.on_redirect { true }
     resp = @resource.delete
-    resp.code.should == 200
+    resp.should be_ok
   end
 
   it "should not redirect on DELETE if the redirection callback returns false" do
-    @resource.on_redirect { false }
-    lambda {
-      @resource.delete
-    }.should raise_error(Resourceful::UnsuccessfulHttpRequestError)
+    resp = @resource.delete
+    resp.should be_redirect
   end
 end
 

data/spec/{acceptance_spec.rb → old_acceptance_specs.rb}

@@ -6,23 +6,12 @@ require Pathname(__FILE__).dirname + 'acceptance_shared_specs'
 
 
 describe Resourceful do
-  it_should_behave_like 'simple http server'
 
   describe 'working with a resource' do
     before do
       @accessor = Resourceful::HttpAccessor.new
     end
 
-    it 'should #get a resource, and return a response object' do
-      resource = @accessor.resource('http://localhost:3000/get')
-      resp = resource.get
-      resp.should be_instance_of(Resourceful::Response)
-      resp.code.should == 200
-      resp.body.should == 'Hello, world!'
-      resp.header.should be_instance_of(Resourceful::Header)
-      resp.header['Content-Type'].should == ['text/plain']
-    end
-
     it 'should set additional headers on the #get' do
       resource = @accessor.resource('http://localhost:3000/echo_header')
       resp = resource.get(:foo => :bar)
@@ -31,36 +20,6 @@ describe Resourceful do
       resp.body.should =~ /"HTTP_FOO"=>"bar"/
     end
 
-    it 'should #post a resource, and return the response' do
-      resource = @accessor.resource('http://localhost:3000/post')
-      resp = resource.post('Hello world from POST', :content_type => 'text/plain')
-      resp.should be_instance_of(Resourceful::Response)
-      resp.code.should == 201
-      resp.body.should == 'Hello world from POST'
-      resp.header.should be_instance_of(Resourceful::Header)
-      resp.header['Content-Type'].should == ['text/plain']
-    end
-
-    it 'should #put a resource, and return the response' do
-      resource = @accessor.resource('http://localhost:3000/put')
-      resp = resource.put('Hello world from PUT', :content_type => 'text/plain')
-      resp.should be_instance_of(Resourceful::Response)
-      resp.code.should == 200
-      resp.body.should == 'Hello world from PUT'
-      resp.header.should be_instance_of(Resourceful::Header)
-      resp.header['Content-Type'].should == ['text/plain']
-    end
-
-    it 'should #delete a resource, and return a response' do
-      resource = @accessor.resource('http://localhost:3000/delete')
-      resp = resource.delete
-      resp.should be_instance_of(Resourceful::Response)
-      resp.code.should == 200
-      resp.body.should == 'KABOOM!'
-      resp.header.should be_instance_of(Resourceful::Header)
-      resp.header['Content-Type'].should == ['text/plain']
-    end
-
     it 'should take an optional default header for reads' do
       resource = @accessor.resource('http://localhost:3000/echo_header', :foo => :bar)
       resp = resource.get
@@ -98,26 +57,21 @@ describe Resourceful do
       describe 'registering callback' do
         before do
           @resource = @accessor.resource('http://localhost:3000/redirect/301?http://localhost:3000/get')
-          @callback = mock('callback')
-          @callback.stub!(:call).and_return(true)
-
-          @resource.on_redirect { @callback.call }
         end
 
         it 'should allow a callback to be registered' do
           @resource.should respond_to(:on_redirect)
         end
 
-        it 'should perform a registered callback on redirect' do
-          @callback.should_receive(:call).and_return(true)
-          @resource.get
+        it 'should perform a redirect if the callback is true' do
+          @resource.on_redirect { true }
+          @resource.get.should be_successful
         end
 
         it 'should not perform the redirect if the callback returns false' do
-          @callback.should_receive(:call).and_return(false)
-          lambda {
-            @resource.get
-          }.should raise_error(Resourceful::UnsuccessfulHttpRequestError)
+          @resource.on_redirect { false }
+          @resource.get
+          @resource.get.should be_redirect
         end
       end
 
@@ -224,9 +178,8 @@ describe Resourceful do
         resource = @accessor.resource(uri)
         resp = resource.get
         resp.should be_authoritative
-        resp.header['Cache-Control'].should include('must-revalidate')
 
-        resp2 = resource.get
+        resp2 = resource.get(:cache_control => "max-age=0")
         resp2.should be_authoritative
         resp2.should == resp
       end
@@ -242,7 +195,7 @@ describe Resourceful do
         resp2.should_not == resp
       end
 
-      describe 'Cache-Control' do
+      describe 'Server provided Cache-Control' do
 
         it 'should cache anything with "Cache-Control: public"' do
           uri = URI.escape('http://localhost:3000/header?{Cache-Control: public}')
@@ -260,10 +213,10 @@ describe Resourceful do
           uri = URI.escape('http://localhost:3000/header?{Cache-Control: private}')
           resource = @accessor.resource(uri)
           resp = resource.get
-          resp.authoritative?.should be_true
+          resp.should be_authoritative
 
           resp2 = resource.get
-          resp2.authoritative?.should be_false
+          resp2.should_not be_authoritative
 
           resp2.should == resp
         end
@@ -314,6 +267,23 @@ describe Resourceful do
 
       end
 
+      describe 'Client provided Cache-Control' do
+
+        it 'should revalidate anything that is older than "Cache-Control: max-age" value' do
+          a_minute_ago = (Time.now - 60).httpdate
+          uri = URI.escape("http://localhost:3000/header?{Cache-Control: max-age=120, Date: \"#{a_minute_ago}\"}")
+          resource = @accessor.resource(uri)
+          resp = resource.get
+          resp.authoritative?.should be_true
+
+          resp.expired?.should be_false
+
+          resp2 = resource.get({:cache_control => "max-age=1"})
+          resp2.authoritative?.should be_true
+        end
+
+      end
+
     end
 
     describe 'authorization' do

data/spec/simple_sinatra_server.rb

@@ -0,0 +1,74 @@
+
+require 'sinatra'
+
+def any(path, opts={}, &blk)
+  %w[head get post put delete].each do |verb|
+    send verb, path, opts, &blk
+  end
+end
+
+def set_request_params_as_response_header!
+  params.each { |k,v| response[k] = v }
+end
+
+def set_request_header_in_body!
+  response['Content-Type'] ||= "application/yaml"
+  headers = request.env.reject { |k,v| !v.is_a?(String) }
+  headers.to_yaml
+end
+
+get '/' do
+  "Hello, world!"
+end
+
+post '/' do
+  request.body
+end
+
+put '/' do
+  request.body
+end
+
+delete '/' do
+  "Deleted"
+end
+
+# Responds with the method used for the request
+any '/method' do
+  request.env['REQUEST_METHOD']
+end
+
+# Responds with the response code in the url
+any '/code/:code' do
+  status params[:code]
+  set_request_params_as_response_header!
+  set_request_header_in_body!
+end
+
+# Sets the response header from the query string, and
+# dumps the request header into the body as yaml for inspection
+any '/header' do
+  set_request_params_as_response_header!
+  set_request_header_in_body!
+end
+  
+# Takes a modified=httpdate as a query param, and a If-Modified-Since header, 
+# and responds 304 if they're the same
+get '/cached' do
+  set_request_params_as_response_header!
+  set_request_header_in_body!
+
+  response['Last-Modified'] = params[:modified]
+
+  modtime = params[:modified]
+  imstime = request.env['HTTP_IF_MODIFIED_SINCE']
+  
+  if modtime && imstime && modtime == imstime
+    status 304
+  end
+end
+
+Sinatra::Default.set(
+  :port => 3000
+)
+

data/spec/simple_sinatra_server_spec.rb

@@ -0,0 +1,98 @@
+
+require 'rubygems'
+require 'sinatra'
+require 'sinatra/test/rspec'
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "GET /" do
+  it 'should render "Hello, world!"' do
+    get '/'
+    @response.should be_ok
+    @response.body.should == "Hello, world!"
+  end
+end
+
+describe "POST /" do
+  it 'should be 201 with no body' do
+    post '/'
+    @response.should be_ok
+    @response.body.should == ""
+  end
+
+  it 'should return the request body as the response body' do
+    body = "Some text"
+    post '/', body
+    @response.should be_ok
+    @response.body.should == body
+  end
+end
+
+describe "PUT /" do
+  it 'should be 200 with no body' do
+    put '/'
+    @response.should be_ok
+    @response.body.should == ""
+  end
+
+  it 'should return the request body as the response body' do
+    body = "Some text"
+    put '/', body
+    @response.should be_ok
+    @response.body.should == body
+  end
+end
+
+describe "DELETE /" do
+  it 'should render "Deleted"' do
+    delete '/'
+    @response.should be_ok
+    @response.body.should == "Deleted"
+  end
+end
+
+describe "/method" do
+  it 'should respond with the method used to make the request' do
+    %w[get post put delete].each do |verb|
+      send verb, '/method'
+      @response.body.should == verb.upcase
+    end
+  end
+end
+
+describe "/code/nnn" do
+  it 'should respond with the code provided in the url' do
+    # Just try a handful
+    [200, 201, 301, 302, 304, 403, 404, 500].each do |code|
+      get "/code/#{code}"
+      @response.status.should == code
+    end
+  end
+end
+
+describe "/header" do
+  it 'should set response headers from the query string' do
+    get "/header", "X-Foo" => "Bar"
+    @response['X-Foo'].should == "Bar"
+  end
+
+  it 'should dump the request headers into the body as yaml' do
+    get '/header', {}, "X-Foo" => "Bar"
+    body = YAML.load(@response.body)
+    body['X-Foo'].should == "Bar"
+  end
+end
+
+describe "/cache" do
+  it 'should be normal 200 if the modified query param and the ims header dont match' do
+    now = Time.now
+    get '/cached', {"modified" => now.httpdate}, {"HTTP_IF_MODIFIED_SINCE" => (now - 3600).httpdate}
+    @response.should be_ok
+  end
+
+  it 'should be 304 if the modified query param and the ims header are the same' do
+    now = Time.now
+    get '/cached', {"modified" => now.httpdate}, {"HTTP_IF_MODIFIED_SINCE" => now.httpdate}
+    @response.status.should == 304
+  end
+end