rack-robustness 1.0.0 → 1.1.0

data/CHANGELOG.md

@@ -1,3 +1,51 @@
+# 1.1.0 / 2013-04-16
+
+* Fixed catching of non standard errors (e.g. SecurityError)
+
+* Global headers are now correctly overrided by specific per-exception headers
+
+* Renamed `#on` as `#rescue` for better capturing semantics of `on` blocks (now an alias).
+
+* Added last resort exception handling if an error occurs during exception handling itself.
+  In `no_catch_all` mode, the exception is simply reraised; otherwise a default 500 error
+  is returned with a safe message.
+
+* Added a shortcut form for `#rescue` clauses allowing values directly, e.g.,
+
+        use Rack::Robustness do |g|
+          g.rescue(SecurityError, 403)
+        end
+
+* Added suppport for ensure clause(s), called after `rescue` blocks on every error
+
+* Rack's `env` is now available in all error handling blocks, e.g.,
+
+        use Rack::Robustness do |g|
+          g.status{|ex| ... env ... }
+          g.body  {|ex| ... env ... }
+          g.rescue(SecurityError){|ex| ... env ... }
+          g.ensure{|ex| ... env ... }
+        end
+
+* Similarly, Rack::Robustness now internally uses instances of Rack::Request and Rack::Response,
+  which are available under `request` and `response` in all blocks. The specific Response
+  object to use can be built using the `response` DSL method, e.g.,
+
+        use Rack::Robustness do |g|
+          g.response{|ex| MyOwnRackResponse.new }
+        end
+
+* Rack::Robustness may now be subclassed as an alternative to inline use shown above, e.g.
+
+        class Shield < Rack::Robustness
+          self.body  {|ex| ... }
+          self.rescue(SecurityError){|ex| ... }
+          ...
+        end
+
+        # in Rack-based configuration
+        use Shield
+
 # 1.0.0 / 2013-02-26
 
 * Enhancements

data/README.md

@@ -1,15 +1,59 @@
 # Rack::Robustness, the rescue clause of your Rack stack.
 
-Rack::Robustness is the rescue clause of your Rack's call stack. In other words, a middleware that ensures the robustness of your web stack, because exceptions occur either intentionally or unintentionally. It scales from zero configuration (a default shield) to specific rescue clauses for specific errors.
+Rack::Robustness is the rescue clause of your Rack's call stack. In other words, a middleware that ensures the robustness of your web stack, because exceptions occur either intentionally or unintentionally. Rack::Robustness is the rack middleware you would have written manually (see below) but provides a DSL for scaling from zero configuration (a default shield) to specific rescue clauses for specific errors.
 
 [![Build Status](https://secure.travis-ci.org/blambeau/rack-robustness.png)](http://travis-ci.org/blambeau/rack-robustness)
 [![Dependency Status](https://gemnasium.com/blambeau/rack-robustness.png)](https://gemnasium.com/blambeau/rack-robustness)
 
+```ruby
+##
+#
+# The middleware you would have written
+#
+class Robustness
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    @app.call(env)
+  rescue ArgumentError => ex
+    [400, { 'Content-Type' => 'text/plain' }, [ ex.message ] ]  # suppose the message can be safely used
+  rescue SecurityError => ex
+    [403, { 'Content-Type' => 'text/plain' }, [ ex.message ] ]
+  ensure
+    env['rack.errors'].write(ex.message) if ex
+  end
+
+end
+```
+
+...becomes...
+
+```ruby
+use Rack::Robustness do |g|
+  g.on(ArgumentError){|ex| 400 }
+  g.on(SecurityError){|ex| 403 }
+
+  g.content_type 'text/plain'
+
+  g.body{|ex|
+    ex.message
+  }
+
+  g.ensure(true){|ex|
+    env['rack.errors'].write(ex.message)
+  }
+end
+```
+
 ## Links
 
-https://github.com/blambeau/rack-robustness
+* https://github.com/blambeau/rack-robustness
+* http://www.revision-zero.org/rack-robustness
 
-## Why? 
+## Why?
 
 In my opinion, Sinatra's error handling is sometimes a bit limited for real-case needs. So I came up with something a bit more Rack-ish, that allows handling exceptions actively, because exceptions occur and that you'll handle them... enventually. A more theoretic argumentation would be:
 
@@ -17,20 +61,22 @@ In my opinion, Sinatra's error handling is sometimes a bit limited for real-case
 * The behavior to adopt when obstacles occur is not necessary defined where the exception is thrown, but often higher in the call stack.
 * In ruby web apps, the Rack's call stack is a very important part of your stack. Middlewares, routes and controllers do rarely rescue all errors, so it's still your job to rescue errors higher in the call stack.
 
-Rack::Robustness is therefore a try/catch mechanism as a middleware, to be used along the Rack call stack as you would use a standard one in a more conventional call stack:
+Rack::Robustness is therefore a try/catch/finally mechanism as a middleware, to be used along the Rack call stack as you would use a standard one in a more conventional call stack:
 
 ```java
 try {
   // main shield, typically in a main
-  
+
   try {
     // try to achieve a goal here
   } catch (...) {
     // fallback to an alternative
+  } finally {
+    // ensure something is executed in all cases
   }
-  
+
   // continue your flow
-  
+
 } catch (...) {
   // something goes really wrong, inform the user as you can
 }
@@ -53,6 +99,8 @@ class Main < Sinatra::Base
   use Rack::Robustness do
     # fallback to an alternative
     # 3xx, 4xx errors maybe
+
+    # ensure something is executed in all cases
   end
 
   # try to achieve your goal through standard routes
@@ -60,7 +108,7 @@ class Main < Sinatra::Base
 end
 ```
 
-## Examples
+## Additional examples
 
 ```ruby
 class App < Sinatra::Base
@@ -102,6 +150,9 @@ class App < Sinatra::Base
     # we use SecurityError for handling forbidden accesses.
     # The default status is 403 here
     g.on(SecurityError){|ex| 403 }
+
+    # ensure logging in all exceptional cases
+    g.ensure(true){|ex| env['rack.errors'].write(ex.message) }
   end
 
   get '/some/route/:id' do |id|
@@ -202,6 +253,27 @@ use Rack::Robustness do |g|
 end
 ```
 
+## Ensure common block in happy/exceptional/all cases
+
+```ruby
+##
+# Ensure in all cases (no arg) or exceptional cases only (true)
+#
+use Rack::Robustness do |g|
+
+  # Ensure in all cases
+  g.ensure{|ex|
+    # ex might be nil here
+  }
+
+  # Ensure in exceptional cases only (for logging purposes for instance)
+  g.ensure(true){|ex|
+    # an exception occured, ex is never nil
+    env['rack.errors'].write("#{ex.message}\n")
+  }
+end
+```
+
 ## Don't catch all!
 
 ```ruby

data/lib/rack/robustness.rb

@@ -1,95 +1,210 @@
 module Rack
   class Robustness
 
-    VERSION = "1.0.0".freeze
+    VERSION = "1.1.0".freeze
 
-    NIL_HANDLER = lambda{|ex| nil }
-
-    def initialize(app)
-      @app       = app
-      @handlers  = {}
-      @status    = 500
-      @headers   = {'Content-Type' => "text/plain"}
-      @body      = ["Sorry, a fatal error occured."]
-      @catch_all = true
-      yield self if block_given?
-      on(Object){|ex| [@status, {}, @body]} if @catch_all
-      @headers.freeze
-      @body.freeze
-      @handlers.freeze
+    def self.new(app, &bl)
+      return super(app) if bl.nil? and not(Robustness==self)
+      Class.new(self).install(&bl).new(app)
     end
 
     ##
     # Configuration
+    module DSL
 
-    def no_catch_all
-      @catch_all = false
-    end
+      NIL_HANDLER = lambda{|ex| nil }
 
-    def on(ex_class, &bl)
-      @handlers[ex_class] = bl || NIL_HANDLER
-    end
+      def inherited(x)
+        x.reset
+      end
 
-    def status(s=nil, &bl)
-      @status = s || bl
-    end
+      def reset
+        @rescue_clauses   = {}
+        @ensure_clauses   = []
+        @status_clause    = 500
+        @headers_clause   = {'Content-Type' => "text/plain"}
+        @body_clause      = ["Sorry, a fatal error occured."]
+        @response_builder = lambda{|ex| ::Rack::Response.new }
+        @catch_all        = true
+      end
+      attr_reader :rescue_clauses, :ensure_clauses, :status_clause,
+                  :headers_clause, :body_clause, :catch_all, :response_builder
+
+      def install
+        yield self if block_given?
+        on(Object){|ex|
+          [status_clause, {}, body_clause]
+        } if @catch_all
+        @headers_clause.freeze
+        @body_clause.freeze
+        @rescue_clauses.freeze
+        @ensure_clauses.freeze
+        self
+      end
 
-    def headers(h=nil, &bl)
-      if h.nil?
-        @headers = bl
-      else
-        @headers.merge!(h)
+      def no_catch_all
+        @catch_all = false
       end
-    end
 
-    def content_type(ct=nil, &bl)
-      headers('Content-Type' => ct || bl)
-    end
+      def response(&bl)
+        @response_builder = bl
+      end
+
+      def rescue(ex_class, handler = nil, &bl)
+        @rescue_clauses[ex_class] = handler || bl || NIL_HANDLER
+      end
+      alias :on :rescue
+
+      def ensure(bypass_on_success = false, &bl)
+        @ensure_clauses << [bypass_on_success, bl]
+      end
+
+      def status(s=nil, &bl)
+        @status_clause = s || bl
+      end
+
+      def headers(h=nil, &bl)
+        if h.nil?
+          @headers_clause = bl
+        else
+          @headers_clause.merge!(h)
+        end
+      end
+
+      def content_type(ct=nil, &bl)
+        headers('Content-Type' => ct || bl)
+      end
+
+      def body(b=nil, &bl)
+        @body_clause = b.nil? ? bl : (String===b ? [ b ] : b)
+      end
+
+    end # module DSL
+    extend DSL
+
+  public
 
-    def body(b=nil, &bl)
-      @body = b.nil? ? bl : (String===b ? [ b ] : b)
+    def initialize(app)
+      @app = app
     end
 
     ##
     # Rack's call
 
     def call(env)
-      @app.call(env)
+      dup.call!(env)
     rescue => ex
-      handler = error_handler(ex.class)
-      raise unless handler
-      handle_response(handler, ex)
+       catch_all ? last_resort(ex) : raise(ex)
+    end
+
+  protected
+
+    def call!(env)
+      @env, @request = env, Rack::Request.new(env)
+      triple = @app.call(env)
+      handle_happy(triple)
+    rescue Exception => ex
+      handle_rescue(ex)
+    ensure
+      handle_ensure(ex)
     end
 
   private
 
-    def handle_response(response, ex)
-      case response
-      when NilClass then handle_response([@status,  {},       @body], ex)
-      when Fixnum   then handle_response([response, {},       @body], ex)
-      when String   then handle_response([@status,  {},       response], ex)
-      when Hash     then handle_response([@status,  response, @body], ex)
-      when Proc     then handle_response(response.call(ex), ex)
-      else
-        status, headers, body = response.map{|x| handle_value(x, ex) }
-        [ status,
-          handle_value(@headers, ex).merge(headers),
-          body ]
+    attr_reader :env, :request, :response
+
+    [ :response_builder,
+      :rescue_clauses,
+      :ensure_clauses,
+      :status_clause,
+      :headers_clause,
+      :body_clause,
+      :catch_all ].each do |m|
+      define_method(m){|*args, &bl|
+        self.class.send(m, *args, &bl)
+      }
+    end
+
+    def handle_happy(triple)
+      s, h, b = triple
+      @response = Response.new(b, s, h)
+      @response.finish
+    end
+
+    def handle_rescue(ex)
+      begin
+        # build a response instance
+        @response = instance_exec(ex, &response_builder)
+
+        # populate it if a rescue clause can be found
+        if rescue_clause = find_rescue_clause(ex.class)
+          handle_error(ex, rescue_clause)
+          return @response.finish
+        end
+
+        # no_catch_all mode, let reraise it later
+      rescue Exception => ex2
+        return catch_all ? last_resort(ex2) : raise(ex2)
+      end
+
+      # we are in no_catch_all mode, reraise
+      raise(ex)
+    end
+
+    def handle_ensure(ex)
+      @response ||= begin
+        status, headers, body = last_resort(ex)
+        ::Rack::Response.new(body, status, headers)
       end
+      ensure_clauses.each{|(bypass,ensurer)|
+        instance_exec(ex, &ensurer) if ex or not(bypass)
+      }
     end
 
-    def handle_value(value, ex)
-      case value
-      when Proc then value.call(ex)
-      when Hash then value.each_with_object({}){|(k,v),h| h[k] = handle_value(v, ex)}
+    def handle_error(ex, rescue_clause)
+      case rescue_clause
+      when NilClass then handle_error(ex, [status_clause,  {},           body_clause])
+      when Fixnum   then handle_error(ex, [rescue_clause,  {},           body_clause])
+      when String   then handle_error(ex, [status_clause,  {},           rescue_clause])
+      when Hash     then handle_error(ex, [status_clause, rescue_clause, body_clause])
+      when Proc     then handle_error(ex, handle_value(ex, rescue_clause))
       else
-        value
+        status, headers, body = rescue_clause
+        handle_status(ex, status)
+        handle_headers(ex, headers)
+        handle_headers(ex, headers_clause)
+        handle_body(ex, body)
+      end
+    end
+
+    def handle_status(ex, status)
+      @response.status = handle_value(ex, status)
+    end
+
+    def handle_headers(ex, headers)
+      handle_value(ex, headers).each_pair do |key,value|
+        @response[key] ||= handle_value(ex, value)
       end
     end
 
-    def error_handler(ex_class)
+    def handle_body(ex, body)
+      body = handle_value(ex, body)
+      @response.body = body.is_a?(String) ? [ body ] : body
+    end
+
+    def handle_value(ex, value)
+      value.is_a?(Proc) ? instance_exec(ex, &value) : value
+    end
+
+    def find_rescue_clause(ex_class)
       return nil if ex_class.nil?
-      @handlers.fetch(ex_class){ error_handler(ex_class.superclass) }
+      rescue_clauses.fetch(ex_class){ find_rescue_clause(ex_class.superclass) }
+    end
+
+    def last_resort(ex)
+      [ 500,
+        {'Content-Type' => 'text/plain'},
+        [ 'An internal error occured, sorry for the disagreement.' ] ]
     end
 
  end # class Robustness

data/spec/spec_helper.rb

@@ -4,6 +4,29 @@ require 'rack/robustness'
 require 'rack/test'
 
 module SpecHelpers
+
+  def mock_app(clazz = Rack::Robustness, &bl)
+    Rack::Builder.new do
+      use clazz, &bl
+      map '/happy' do
+        run lambda{|env| [200, {'Content-Type' => 'text/plain'}, ['happy']]}
+      end
+      map "/argument-error" do
+        run lambda{|env| raise ArgumentError, "an argument error" }
+      end
+      map "/type-error" do
+        run lambda{|env| raise TypeError, "a type error" }
+      end
+      map "/security-error" do
+        run lambda{|env| raise SecurityError, "a security error" }
+      end
+    end
+  end
+
+  def app
+    mock_app{}
+  end
+
 end
 
 RSpec.configure do |c|

data/spec/test_context.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+describe Rack::Robustness, 'the context in which blocks execute' do
+  include Rack::Test::Methods
+
+  let(:app){
+    mock_app do |g|
+      g.response{|ex|
+        raise "Invalid context" unless env && request
+        Rack::Response.new
+      }
+      g.body{|ex|
+        raise "Invalid context" unless env && request && response
+        if response.status == 400
+          "argument-error"
+        else
+          "security-error"
+        end
+      }
+      g.rescue(ArgumentError){|ex|
+        raise "Invalid context" unless env && request && response
+        400
+      }
+      g.rescue(SecurityError){|ex|
+        raise "Invalid context" unless env && request && response
+        403
+      }
+      g.ensure{|ex|
+        raise "Invalid context" unless env && request && response
+        $seen_ex = ex
+      }
+    end
+  }
+
+  it 'should let `env`, `request` and `response` be available in all blocks' do
+    get '/argument-error'
+    last_response.status.should eq(400)
+    last_response.body.should eq('argument-error')
+  end
+
+  it 'executes the ensure block as well' do
+    get '/argument-error'
+    $seen_ex.should be_a(ArgumentError)
+  end
+
+end

data/spec/test_ensure.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+describe Rack::Robustness, 'ensure' do
+  include Rack::Test::Methods
+
+  let(:app){
+    mock_app do |g|
+      g.ensure(true) {|ex| $seen_true  = [ex.class] }
+      g.ensure(false){|ex| $seen_false = [ex.class] }
+      g.ensure       {|ex| $seen_none  = [ex.class] }
+      g.status 400
+      g.on(ArgumentError){|ex| "error" }
+    end
+  }
+
+  before do
+    $seen_true = $seen_false = $seen_none = nil
+  end
+
+  it 'should be called in all cases when an error occurs' do
+    get '/argument-error'
+    last_response.status.should eq(400)
+    last_response.body.should eq("error")
+    $seen_true.should eq([ArgumentError])
+    $seen_false.should eq([ArgumentError])
+    $seen_none.should eq([ArgumentError])
+  end
+
+  it 'should not be called when explicit bypass on happy paths' do
+    get '/happy'
+    last_response.status.should eq(200)
+    last_response.body.should eq("happy")
+    $seen_true.should be_nil
+    $seen_false.should eq([NilClass])
+    $seen_none.should eq([NilClass])
+  end
+
+end

data/spec/test_last_resort.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+describe Rack::Robustness, 'last resort' do
+  include Rack::Test::Methods
+
+  before do
+    $seen_ex = nil
+  end
+
+  context 'when the response cannot be built and no catch all' do
+    let(:app){
+      mock_app do |g|
+        g.no_catch_all
+        g.response{|ex| NoSuchResponseClass.new }
+        g.ensure(true){|ex| $seen_ex = ex }
+      end
+    }
+
+    it 'reraises the internal error' do
+      lambda{
+        get '/argument-error'
+      }.should raise_error(NameError, /NoSuchResponseClass/)
+    end
+
+    it 'passes into the ensure block with the original error' do
+      lambda{
+        get '/argument-error'
+      }.should raise_error(NameError, /NoSuchResponseClass/)
+      $seen_ex.should be_a(ArgumentError)
+    end
+  end
+
+  context 'when the response cannot be built and catch all' do
+    let(:app){
+      mock_app do |g|
+        g.response{|ex| NoSuchResponseClass.new }
+      end
+    }
+
+    it 'falls back to last resort response' do
+      get '/argument-error'
+      last_response.status.should eq(500)
+      last_response.content_type.should eq("text/plain")
+      last_response.body.should eq("An internal error occured, sorry for the disagreement.")
+    end
+  end
+
+  context 'when an ensure block raises an error and no catch all' do
+    let(:app){
+      mock_app do |g|
+        g.no_catch_all
+        g.ensure{|ex| NoSuchResponseClass.new }
+      end
+    }
+
+    it 'reraises the internal error' do
+      lambda{
+        get '/argument-error'
+      }.should raise_error(NameError, /NoSuchResponseClass/)
+    end
+  end
+
+  context 'when an ensure block raises an error and catch all' do
+    let(:app){
+      mock_app do |g|
+        g.ensure{|ex| NoSuchResponseClass.new }
+      end
+    }
+
+    it 'reraises the internal error' do
+      get '/argument-error'
+      last_response.status.should eq(500)
+      last_response.content_type.should eq("text/plain")
+      last_response.body.should eq("An internal error occured, sorry for the disagreement.")
+    end
+  end
+
+  context 'when the response block fails and the ensure block uses the response object' do
+    let(:app){
+      mock_app do |g|
+        g.response{|ex| NoSuchResponseClass.new }
+        g.ensure{|ex| $seen_response = response }
+      end
+    }
+
+    before do
+      $seen_response = nil
+    end
+
+    it 'sets a default response object for the ensure clause' do
+      get '/argument-error'
+      last_response.status.should eq(500)
+      last_response.content_type.should eq("text/plain")
+      last_response.body.should eq("An internal error occured, sorry for the disagreement.")
+      $seen_response.should_not be_nil
+    end
+  end
+
+end

data/spec/test_rescue.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+describe Rack::Robustness, 'rescue' do
+  include Rack::Test::Methods
+
+  let(:app){
+    mock_app do |g|
+      g.status 400
+      g.rescue(ArgumentError){|ex| 'argument-error' }
+      g.rescue(SecurityError, 'security-error')
+      g.on(TypeError)        {|ex| 'type-error'     }
+    end
+  }
+
+  it 'correctly rescues specified errors' do
+    get '/argument-error'
+    last_response.status.should eq(400)
+    last_response.body.should eq("argument-error")
+  end
+
+  it 'correctly support a non-block shortcut' do
+    get '/security-error'
+    last_response.status.should eq(400)
+    last_response.body.should eq("security-error")
+  end
+
+  it 'is has a `on` alias' do
+    get '/type-error'
+    last_response.status.should eq(400)
+    last_response.body.should eq("type-error")
+  end
+
+end

data/spec/test_response.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+describe Rack::Robustness, 'response' do
+  include Rack::Test::Methods
+
+  class MyFooResponse < Rack::Response
+
+    def initialize(*args)
+      super
+      self['Content-Type'] = "application/json"
+    end
+
+    def each
+      yield("response text")
+    end
+
+  end
+
+  let(:app){
+    mock_app do |g|
+      g.status 400
+      g.response{|ex| MyFooResponse.new }
+    end
+  }
+
+  it 'correctly sets the status' do
+    get '/argument-error'
+    last_response.status.should eq(400)
+  end
+
+  it 'correctly sets the body' do
+    get '/argument-error'
+    last_response.body.should eq("response text")
+  end
+
+  it 'correctly sets the content type' do
+    get '/argument-error'
+    last_response.content_type.should eq("application/json")
+  end
+
+end

data/spec/test_robustness.rb

@@ -2,21 +2,6 @@ require 'spec_helper'
 describe Rack::Robustness do
   include Rack::Test::Methods
 
-  def mock_app(&bl)
-    Rack::Builder.new do
-      use Rack::Robustness, &bl
-      map '/happy' do
-        run lambda{|env| [200, {'Content-Type' => 'text/plain'}, ['happy']]}
-      end
-      map "/argument-error" do
-        run lambda{|env| raise ArgumentError, "an argument error" }
-      end
-      map "/type-error" do
-        run lambda{|env| raise TypeError, "a type error" }
-      end
-    end
-  end
-
   shared_examples_for 'A transparent middleware for happy paths' do
 
     it 'let happy responses unchanged' do
@@ -40,6 +25,13 @@ describe Rack::Robustness do
       last_response.content_type.should eq("text/plain")
       last_response.body.should eq("Sorry, a fatal error occured.")
     end
+
+    it 'catches all exceptions by default' do
+      get '/security-error'
+      last_response.status.should eq(500)
+      last_response.content_type.should eq("text/plain")
+      last_response.body.should eq("Sorry, a fatal error occured.")
+    end
   end
 
   context 'with a status, content_type and body constants' do

data/spec/test_subclass.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+describe "Rack::Robustness subclasses" do
+  include Rack::Test::Methods
+
+  class Shield < Rack::Robustness
+    self.body{|ex| ex.message }
+    self.rescue(ArgumentError){|ex| 400 }
+  end
+
+  let(:app){
+    mock_app(Shield)
+  }
+
+  it 'works as expected' do
+    get '/argument-error'
+    last_response.status.should eq(400)
+    last_response.body.should eq("an argument error")
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-robustness
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-26 00:00:00.000000000 Z
+date: 2013-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -96,7 +96,13 @@ files:
 - Rakefile
 - README.md
 - spec/spec_helper.rb
+- spec/test_context.rb
+- spec/test_ensure.rb
+- spec/test_last_resort.rb
+- spec/test_rescue.rb
+- spec/test_response.rb
 - spec/test_robustness.rb
+- spec/test_subclass.rb
 - tasks/gem.rake
 - tasks/spec_test.rake
 homepage: https://github.com/blambeau/rack-robustness
@@ -113,7 +119,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2934394792950840478
+      hash: -3037208557824391971
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -122,10 +128,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Rack::Robustness, the rescue clause of your Rack stack.
 test_files:
 - spec/spec_helper.rb
+- spec/test_context.rb
+- spec/test_ensure.rb
+- spec/test_last_resort.rb
+- spec/test_rescue.rb
+- spec/test_response.rb
 - spec/test_robustness.rb
+- spec/test_subclass.rb