grape 0.16.2 → 0.17.0

data/lib/grape/validations/validators/at_least_one_of.rb

@@ -5,7 +5,7 @@ module Grape
       def validate!(params)
         super
         if scope_requires_params && no_exclusive_params_are_present
-          fail Grape::Exceptions::Validation, params: all_keys, message: message(:at_least_one)
+          raise Grape::Exceptions::Validation, params: all_keys, message: message(:at_least_one)
         end
         params
       end

data/lib/grape/validations/validators/base.rb

@@ -35,19 +35,29 @@ module Grape
       # @return [void]
       def validate!(params)
         attributes = AttributesIterator.new(self, @scope, params)
-        attributes.each do |resource_params, attr_name|
-          if @required || (resource_params.respond_to?(:key?) && resource_params.key?(attr_name))
+        array_errors = []
+        attributes.each do |resource_params, attr_name, inside_array|
+          next unless @required || (resource_params.respond_to?(:key?) && resource_params.key?(attr_name))
+
+          begin
             validate_param!(attr_name, resource_params)
+          rescue Grape::Exceptions::Validation => e
+            raise e unless inside_array
+            # we collect errors inside array because
+            # there may be more than one error per field
+            array_errors << e
           end
         end
+
+        raise Grape::Exceptions::ValidationArrayErrors, array_errors if array_errors.any?
       end
 
       def self.convert_to_short_name(klass)
         ret = klass.name.gsub(/::/, '/')
-              .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-              .tr('-', '_')
-              .downcase
+                   .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                   .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                   .tr('-', '_')
+                   .downcase
         File.basename(ret, '_validator')
       end
 

data/lib/grape/validations/validators/coerce.rb

@@ -11,13 +11,10 @@ module Grape
       end
 
       def validate_param!(attr_name, params)
-        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:coerce) unless params.is_a? Hash
+        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:coerce) unless params.is_a? Hash
         new_value = coerce_value(params[attr_name])
-        if valid_type?(new_value)
-          params[attr_name] = new_value
-        else
-          fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:coerce)
-        end
+        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:coerce) unless valid_type?(new_value)
+        params[attr_name] = new_value
       end
 
       private

data/lib/grape/validations/validators/default.rb

@@ -7,7 +7,14 @@ module Grape
       end
 
       def validate_param!(attr_name, params)
-        params[attr_name] = @default.is_a?(Proc) ? @default.call : @default unless params.key?(attr_name)
+        return if params.key? attr_name
+        params[attr_name] = if @default.is_a? Proc
+                              @default.call
+                            elsif @default.frozen? || !duplicatable?(@default)
+                              @default
+                            else
+                              duplicate(@default)
+                            end
       end
 
       def validate!(params)
@@ -20,6 +27,24 @@ module Grape
           end
         end
       end
+
+      private
+
+      # return true if we might be able to dup this object
+      def duplicatable?(obj)
+        !obj.nil? &&
+          obj != true &&
+          obj != false &&
+          !obj.is_a?(Symbol) &&
+          !obj.is_a?(Numeric)
+      end
+
+      # make a best effort to dup the object
+      def duplicate(obj)
+        obj.dup
+      rescue TypeError
+        obj
+      end
     end
   end
 end

data/lib/grape/validations/validators/exactly_one_of.rb

@@ -5,7 +5,7 @@ module Grape
       def validate!(params)
         super
         if scope_requires_params && none_of_restricted_params_is_present
-          fail Grape::Exceptions::Validation, params: all_keys, message: message(:exactly_one)
+          raise Grape::Exceptions::Validation, params: all_keys, message: message(:exactly_one)
         end
         params
       end

data/lib/grape/validations/validators/mutual_exclusion.rb

@@ -7,7 +7,7 @@ module Grape
       def validate!(params)
         super
         if two_or_more_exclusive_params_are_present
-          fail Grape::Exceptions::Validation, params: processing_keys_in_common, message: message(:mutual_exclusion)
+          raise Grape::Exceptions::Validation, params: processing_keys_in_common, message: message(:mutual_exclusion)
         end
         params
       end

data/lib/grape/validations/validators/presence.rb

@@ -8,7 +8,7 @@ module Grape
 
       def validate_param!(attr_name, params)
         return if params.respond_to?(:key?) && params.key?(attr_name)
-        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:presence)
+        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:presence)
       end
     end
   end

data/lib/grape/validations/validators/regexp.rb

@@ -3,7 +3,7 @@ module Grape
     class RegexpValidator < Base
       def validate_param!(attr_name, params)
         return unless params.key?(attr_name) && !params[attr_name].nil? && !(params[attr_name].to_s =~ (options_key?(:value) ? @option[:value] : @option))
-        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:regexp)
+        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:regexp)
       end
     end
   end

data/lib/grape/validations/validators/values.rb

@@ -13,7 +13,7 @@ module Grape
         values = @values.is_a?(Proc) ? @values.call : @values
         param_array = params[attr_name].nil? ? [nil] : Array.wrap(params[attr_name])
         return if param_array.all? { |param| values.include?(param) }
-        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:values)
+        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:values)
       end
 
       private

data/lib/grape/version.rb

@@ -1,4 +1,4 @@
 module Grape
   # The current version of Grape.
-  VERSION = '0.16.2'
+  VERSION = '0.17.0'.freeze
 end

data/spec/grape/api/custom_validations_spec.rb

@@ -8,7 +8,7 @@ describe Grape::Validations do
           def validate_param!(attr_name, params)
             @option = params[:max].to_i if params.key?(:max)
             return if params[attr_name].length <= @option
-            fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: "must be at the most #{@option} characters long"
+            raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: "must be at the most #{@option} characters long"
           end
         end
       end
@@ -87,7 +87,7 @@ describe Grape::Validations do
       module CustomValidationsSpec
         class WithMessageKey < Grape::Validations::PresenceValidator
           def validate_param!(attr_name, _params)
-            fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: :presence
+            raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: :presence
           end
         end
       end
@@ -126,7 +126,7 @@ describe Grape::Validations do
             return unless @option
             # check if user is admin or not
             # as an example get a token from request and check if it's admin or not
-            fail Grape::Exceptions::Validation, params: @attrs, message: 'Can not set Admin only field.' unless request.headers['X-Access-Token'] == 'admin'
+            raise Grape::Exceptions::Validation, params: @attrs, message: 'Can not set Admin only field.' unless request.headers['X-Access-Token'] == 'admin'
           end
         end
       end

data/spec/grape/api/parameters_modification_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Grape::Endpoint do
+  subject { Class.new(Grape::API) }
+
+  def app
+    subject
+  end
+
+  before do
+    subject.namespace :test do
+      params do
+        optional :foo, default: '-abcdef'
+      end
+      get do
+        params[:foo].slice!(0)
+        params[:foo]
+      end
+    end
+  end
+
+  context 'when route modifies param value' do
+    it 'param default should not change' do
+      get '/test'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'abcdef'
+
+      get '/test'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'abcdef'
+
+      get '/test?foo=-123456'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq '123456'
+
+      get '/test'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'abcdef'
+    end
+  end
+end

data/spec/grape/api_spec.rb

@@ -258,7 +258,7 @@ describe Grape::API do
           end
         end
         get '/route_param/1234'
-        expect(last_response.body).to eq("{\"foo\":1234}")
+        expect(last_response.body).to eq('{"foo":1234}')
       end
     end
   end
@@ -302,16 +302,27 @@ describe Grape::API do
 
       describe 'path versioned APIs' do
         before do
-          subject.version 'v1', using: :path
+          subject.version version, using: :path
           subject.enable_root_route!
         end
 
-        it 'without a format' do
-          versioned_get '/', 'v1', using: :path
+        context 'when a single version provided' do
+          let(:version) { 'v1' }
+
+          it 'without a format' do
+            versioned_get '/', 'v1', using: :path
+          end
+
+          it 'with a format' do
+            get '/v1/.json'
+          end
         end
 
-        it 'with a format' do
-          get '/v1/.json'
+        context 'when array of versions provided' do
+          let(:version) { %w(v1 v2) }
+
+          it { versioned_get '/', 'v1', using: :path }
+          it { versioned_get '/', 'v2', using: :path }
         end
       end
 
@@ -363,12 +374,17 @@ describe Grape::API do
     end
 
     context 'format' do
+      module ApiSpec
+        class DummyFormatClass
+        end
+      end
+
       before(:each) do
-        allow_any_instance_of(Object).to receive(:to_json).and_return('abc')
-        allow_any_instance_of(Object).to receive(:to_txt).and_return('def')
+        allow_any_instance_of(ApiSpec::DummyFormatClass).to receive(:to_json).and_return('abc')
+        allow_any_instance_of(ApiSpec::DummyFormatClass).to receive(:to_txt).and_return('def')
 
         subject.get('/abc') do
-          Object.new
+          ApiSpec::DummyFormatClass.new
         end
       end
 
@@ -527,6 +543,36 @@ describe Grape::API do
       expect(last_response.headers['X-Custom-Header']).to eql 'foo'
     end
 
+    it 'runs only the before filter on 405 bad method' do
+      subject.namespace :example do
+        before            { header 'X-Custom-Header', 'foo' }
+        before_validation { raise 'before_validation filter should not run' }
+        after_validation  { raise 'after_validation filter should not run' }
+        after             { raise 'after filter should not run' }
+        get
+      end
+
+      post '/example'
+      expect(last_response.status).to eql 405
+      expect(last_response.headers['X-Custom-Header']).to eql 'foo'
+    end
+
+    it 'runs before filter exactly once on 405 bad method' do
+      already_run = false
+      subject.namespace :example do
+        before do
+          raise 'before filter ran twice' if already_run
+          already_run = true
+          header 'X-Custom-Header', 'foo'
+        end
+        get
+      end
+
+      post '/example'
+      expect(last_response.status).to eql 405
+      expect(last_response.headers['X-Custom-Header']).to eql 'foo'
+    end
+
     context 'when format is xml' do
       it 'returns a 405 for an unsupported method' do
         subject.format :xml
@@ -545,6 +591,21 @@ XML
       end
     end
 
+    context 'when accessing env' do
+      it 'returns a 405 for an unsupported method' do
+        subject.before do
+          _custom_header_1 = headers['X-Custom-Header']
+          _custom_header_2 = env['HTTP_X_CUSTOM_HEADER']
+        end
+        subject.get 'example' do
+          'example'
+        end
+        put '/example'
+        expect(last_response.status).to eql 405
+        expect(last_response.body).to eql '405 Not Allowed'
+      end
+    end
+
     specify '405 responses includes an Allow header specifying supported methods' do
       subject.get 'example' do
         'example'
@@ -1044,7 +1105,7 @@ XML
     describe '.middleware' do
       it 'includes middleware arguments from settings' do
         subject.use ApiSpec::PhonyMiddleware, 'abc', 123
-        expect(subject.middleware).to eql [[ApiSpec::PhonyMiddleware, 'abc', 123]]
+        expect(subject.middleware).to eql [[:use, ApiSpec::PhonyMiddleware, 'abc', 123]]
       end
 
       it 'includes all middleware from stacked settings' do
@@ -1053,9 +1114,9 @@ XML
         subject.use ApiSpec::PhonyMiddleware, 'foo'
 
         expect(subject.middleware).to eql [
-          [ApiSpec::PhonyMiddleware, 123],
-          [ApiSpec::PhonyMiddleware, 'abc'],
-          [ApiSpec::PhonyMiddleware, 'foo']
+          [:use, ApiSpec::PhonyMiddleware, 123],
+          [:use, ApiSpec::PhonyMiddleware, 'abc'],
+          [:use, ApiSpec::PhonyMiddleware, 'foo']
         ]
       end
     end
@@ -1063,7 +1124,7 @@ XML
     describe '.use' do
       it 'adds middleware' do
         subject.use ApiSpec::PhonyMiddleware, 123
-        expect(subject.middleware).to eql [[ApiSpec::PhonyMiddleware, 123]]
+        expect(subject.middleware).to eql [[:use, ApiSpec::PhonyMiddleware, 123]]
       end
 
       it 'does not show up outside the namespace' do
@@ -1074,8 +1135,8 @@ XML
           inner_middleware = middleware
         end
 
-        expect(subject.middleware).to eql [[ApiSpec::PhonyMiddleware, 123]]
-        expect(inner_middleware).to eql [[ApiSpec::PhonyMiddleware, 123], [ApiSpec::PhonyMiddleware, 'abc']]
+        expect(subject.middleware).to eql [[:use, ApiSpec::PhonyMiddleware, 123]]
+        expect(inner_middleware).to eql [[:use, ApiSpec::PhonyMiddleware, 123], [:use, ApiSpec::PhonyMiddleware, 'abc']]
       end
 
       it 'calls the middleware' do
@@ -1091,7 +1152,7 @@ XML
       it 'adds a block if one is given' do
         block = -> {}
         subject.use ApiSpec::PhonyMiddleware, &block
-        expect(subject.middleware).to eql [[ApiSpec::PhonyMiddleware, block]]
+        expect(subject.middleware).to eql [[:use, ApiSpec::PhonyMiddleware, block]]
       end
 
       it 'uses a block if one is given' do
@@ -1132,7 +1193,50 @@ XML
         expect(last_response.body).to eq('Caught in the Net')
       end
     end
+
+    describe '.insert_before' do
+      it 'runs before a given middleware' do
+        m = Class.new(Grape::Middleware::Base) do
+          def call(env)
+            env['phony.args'] ||= []
+            env['phony.args'] << @options[:message]
+            @app.call(env)
+          end
+        end
+
+        subject.use ApiSpec::PhonyMiddleware, 'hello'
+        subject.insert_before ApiSpec::PhonyMiddleware, m, message: 'bye'
+        subject.get '/' do
+          env['phony.args'].join(' ')
+        end
+
+        get '/'
+        expect(last_response.body).to eql 'bye hello'
+      end
+    end
+
+    describe '.insert_after' do
+      it 'runs after a given middleware' do
+        m = Class.new(Grape::Middleware::Base) do
+          def call(env)
+            env['phony.args'] ||= []
+            env['phony.args'] << @options[:message]
+            @app.call(env)
+          end
+        end
+
+        subject.use ApiSpec::PhonyMiddleware, 'hello'
+        subject.insert_after ApiSpec::PhonyMiddleware, m, message: 'bye'
+        subject.get '/' do
+          env['phony.args'].join(' ')
+        end
+
+        get '/'
+        expect(last_response.body).to eql 'hello bye'
+      end
+    end
   end
+
   describe '.http_basic' do
     it 'protects any resources on the same scope' do
       subject.http_basic do |u, _p|
@@ -1243,7 +1347,9 @@ XML
     it 'defaults to a standard logger log format' do
       t = Time.at(100)
       allow(Time).to receive(:now).and_return(t)
-      expect(subject.io).to receive(:write).with("I, [#{Logger::Formatter.new.send(:format_datetime, t)}\##{Process.pid}]  INFO -- : this will be logged\n")
+      message = "this will be logged\n"
+      message = "I, [#{Logger::Formatter.new.send(:format_datetime, t)}\##{Process.pid}]  INFO -- : #{message}" if !defined?(Rails) || Gem::Version.new(Rails::VERSION::STRING) >= Gem::Version.new('4.0')
+      expect(subject.io).to receive(:write).with(message)
       subject.logger.info 'this will be logged'
     end
   end
@@ -1383,7 +1489,7 @@ XML
   describe '.rescue_from' do
     it 'does not rescue errors when rescue_from is not set' do
       subject.get '/exception' do
-        fail 'rain!'
+        raise 'rain!'
       end
       expect { get '/exception' }.to raise_error(RuntimeError, 'rain!')
     end
@@ -1396,16 +1502,46 @@ XML
       end
       subject.rescue_from(ArgumentError) { custom_error! :bob }
       subject.get '/custom_error' do
-        fail ArgumentError
+        raise ArgumentError
       end
       get '/custom_error'
       expect(last_response.body).to eq 'hello bob'
     end
 
+    context 'with multiple apis' do
+      let(:a) { Class.new(Grape::API) }
+      let(:b) { Class.new(Grape::API) }
+
+      before do
+        a.helpers do
+          def foo
+            error!('foo', 401)
+          end
+        end
+        a.rescue_from(:all) { foo }
+        a.get { raise 'boo' }
+        b.helpers do
+          def foo
+            error!('bar', 401)
+          end
+        end
+        b.rescue_from(:all) { foo }
+        b.get { raise 'boo' }
+      end
+
+      it 'avoids polluting global namespace' do
+        env = Rack::MockRequest.env_for('/')
+
+        expect(a.call(env)[2].body).to eq(['foo'])
+        expect(b.call(env)[2].body).to eq(['bar'])
+        expect(a.call(env)[2].body).to eq(['foo'])
+      end
+    end
+
     it 'rescues all errors if rescue_from :all is called' do
       subject.rescue_from :all
       subject.get '/exception' do
-        fail 'rain!'
+        raise 'rain!'
       end
       get '/exception'
       expect(last_response.status).to eql 500
@@ -1417,7 +1553,7 @@ XML
       subject.default_format :json
       subject.rescue_from :all
       subject.get '/exception' do
-        fail 'rain!'
+        raise 'rain!'
       end
       get '/exception'
       expect(last_response.status).to eql 500
@@ -1426,8 +1562,8 @@ XML
 
     it 'rescues only certain errors if rescue_from is called with specific errors' do
       subject.rescue_from ArgumentError
-      subject.get('/rescued') { fail ArgumentError }
-      subject.get('/unrescued') { fail 'beefcake' }
+      subject.get('/rescued') { raise ArgumentError }
+      subject.get('/unrescued') { raise 'beefcake' }
 
       get '/rescued'
       expect(last_response.status).to eql 500
@@ -1443,7 +1579,7 @@ XML
       end
 
       it 'does not re-raise exceptions of type Grape::Exceptions::Base' do
-        subject.get('/custom_exception') { fail ApiSpec::CustomError }
+        subject.get('/custom_exception') { raise ApiSpec::CustomError }
 
         expect { get '/custom_exception' }.not_to raise_error
       end
@@ -1453,7 +1589,7 @@ XML
           rack_response('New Error', e.status)
         end
         subject.get '/custom_error' do
-          fail ApiSpec::CustomError, status: 400, message: 'Custom Error'
+          raise ApiSpec::CustomError, status: 400, message: 'Custom Error'
         end
 
         get '/custom_error'
@@ -1464,7 +1600,7 @@ XML
 
     it 'can rescue exceptions raised in the formatter' do
       formatter = double(:formatter)
-      allow(formatter).to receive(:call) { fail StandardError }
+      allow(formatter).to receive(:call) { raise StandardError }
       allow(Grape::Formatter).to receive(:formatter_for) { formatter }
 
       subject.rescue_from :all do |_e|
@@ -1484,7 +1620,7 @@ XML
         rack_response("rescued from #{e.message}", 202)
       end
       subject.get '/exception' do
-        fail 'rain!'
+        raise 'rain!'
       end
       get '/exception'
       expect(last_response.status).to eql 202
@@ -1503,7 +1639,7 @@ XML
           rack_response("rescued from #{e.class.name}", 500)
         end
         subject.get '/exception' do
-          fail ConnectionError
+          raise ConnectionError
         end
         get '/exception'
         expect(last_response.status).to eql 500
@@ -1514,7 +1650,7 @@ XML
           rack_response("rescued from #{e.class.name}", 500)
         end
         subject.get '/exception' do
-          fail ConnectionError
+          raise ConnectionError
         end
         get '/exception'
         expect(last_response.status).to eql 500
@@ -1525,7 +1661,7 @@ XML
           rack_response("rescued from #{e.class.name}", 500)
         end
         subject.get '/exception' do
-          fail ConnectionError
+          raise ConnectionError
         end
         get '/exception'
         expect(last_response.status).to eql 500
@@ -1539,10 +1675,10 @@ XML
           rack_response("rescued from #{e.class.name}", 500)
         end
         subject.get '/connection' do
-          fail ConnectionError
+          raise ConnectionError
         end
         subject.get '/database' do
-          fail DatabaseError
+          raise DatabaseError
         end
         get '/connection'
         expect(last_response.status).to eql 500
@@ -1556,7 +1692,7 @@ XML
           rack_response("rescued from #{e.class.name}", 500)
         end
         subject.get '/uncaught' do
-          fail CommunicationError
+          raise CommunicationError
         end
         expect { get '/uncaught' }.to raise_error(CommunicationError)
       end
@@ -1568,7 +1704,7 @@ XML
       subject.rescue_from ArgumentError, lambda {
         rack_response('rescued with a lambda', 400)
       }
-      subject.get('/rescue_lambda') { fail ArgumentError }
+      subject.get('/rescue_lambda') { raise ArgumentError }
 
       get '/rescue_lambda'
       expect(last_response.status).to eq(400)
@@ -1579,7 +1715,7 @@ XML
       subject.rescue_from ArgumentError, lambda { |e|
         rack_response(e.message, 400)
       }
-      subject.get('/rescue_lambda') { fail ArgumentError, 'lambda takes an argument' }
+      subject.get('/rescue_lambda') { raise ArgumentError, 'lambda takes an argument' }
 
       get '/rescue_lambda'
       expect(last_response.status).to eq(400)
@@ -1593,21 +1729,56 @@ XML
         def rescue_arg_error
           error!('500 ArgumentError', 500)
         end
+
+        def rescue_no_method_error
+          error!('500 NoMethodError', 500)
+        end
       end
       subject.rescue_from ArgumentError, with: :rescue_arg_error
-      subject.get('/rescue_method') { fail ArgumentError }
+      subject.rescue_from NoMethodError, with: :rescue_no_method_error
+      subject.get('/rescue_arg_error') { raise ArgumentError }
+      subject.get('/rescue_no_method_error') { raise NoMethodError }
 
-      get '/rescue_method'
+      get '/rescue_arg_error'
       expect(last_response.status).to eq(500)
       expect(last_response.body).to eq('500 ArgumentError')
+
+      get '/rescue_no_method_error'
+      expect(last_response.status).to eq(500)
+      expect(last_response.body).to eq('500 NoMethodError')
     end
 
     it 'aborts if the specified method name does not exist' do
       subject.rescue_from :all, with: :not_exist_method
-      subject.get('/rescue_method') { fail StandardError }
+      subject.get('/rescue_method') { raise StandardError }
 
       expect { get '/rescue_method' }.to raise_error(NoMethodError, 'undefined method `not_exist_method\'')
     end
+
+    it 'correctly chooses exception handler if :all handler is specified' do
+      subject.helpers do
+        def rescue_arg_error
+          error!('500 ArgumentError', 500)
+        end
+
+        def rescue_all_errors
+          error!('500 AnotherError', 500)
+        end
+      end
+
+      subject.rescue_from ArgumentError, with: :rescue_arg_error
+      subject.rescue_from :all, with: :rescue_all_errors
+      subject.get('/argument_error') { raise ArgumentError }
+      subject.get('/another_error') { raise NoMethodError }
+
+      get '/argument_error'
+      expect(last_response.status).to eq(500)
+      expect(last_response.body).to eq('500 ArgumentError')
+
+      get '/another_error'
+      expect(last_response.status).to eq(500)
+      expect(last_response.body).to eq('500 AnotherError')
+    end
   end
 
   describe '.rescue_from klass, rescue_subclasses: boolean' do
@@ -1625,13 +1796,13 @@ XML
         rack_response("rescued from #{e.class.name}", 500)
       end
       subject.get '/caught_child' do
-        fail ApiSpec::APIErrors::ChildError
+        raise ApiSpec::APIErrors::ChildError
       end
       subject.get '/caught_parent' do
-        fail ApiSpec::APIErrors::ParentError
+        raise ApiSpec::APIErrors::ParentError
       end
       subject.get '/uncaught_parent' do
-        fail StandardError
+        raise StandardError
       end
 
       get '/caught_child'
@@ -1646,7 +1817,7 @@ XML
         rack_response("rescued from #{e.class.name}", 500)
       end
       subject.get '/caught_child' do
-        fail ApiSpec::APIErrors::ChildError
+        raise ApiSpec::APIErrors::ChildError
       end
 
       get '/caught_child'
@@ -1658,7 +1829,7 @@ XML
         rack_response("rescued from #{e.class.name}", 500)
       end
       subject.get '/uncaught' do
-        fail ApiSpec::APIErrors::ChildError
+        raise ApiSpec::APIErrors::ChildError
       end
       expect { get '/uncaught' }.to raise_error(ApiSpec::APIErrors::ChildError)
     end
@@ -1669,7 +1840,7 @@ XML
       subject.rescue_from :all
       subject.format :txt
       subject.get '/exception' do
-        fail 'rain!'
+        raise 'rain!'
       end
       get '/exception'
       expect(last_response.body).to eql 'rain!'
@@ -1679,7 +1850,7 @@ XML
       subject.rescue_from :all, backtrace: true
       subject.format :txt
       subject.get '/exception' do
-        fail 'rain!'
+        raise 'rain!'
       end
       get '/exception'
       expect(last_response.body.start_with?("rain!\r\n")).to be true
@@ -1690,7 +1861,7 @@ XML
       subject.content_type :foo, 'text/foo'
       subject.rescue_from :all
       subject.get '/exception' do
-        fail 'rain!'
+        raise 'rain!'
       end
       get '/exception.foo'
       expect(last_response.body).to start_with 'rain!'
@@ -1702,7 +1873,7 @@ XML
       subject.content_type :json, 'application/json'
       subject.content_type :foo, 'text/foo'
       subject.get '/exception' do
-        fail 'rain!'
+        raise 'rain!'
       end
       get '/exception.json'
       expect(last_response.body).to eq('{"error":"rain!"}')
@@ -1724,7 +1895,7 @@ XML
         subject.rescue_from :all, backtrace: true
         subject.error_formatter :txt, ApiSpec::CustomErrorFormatter
         subject.get '/exception' do
-          fail 'rain!'
+          raise 'rain!'
         end
         get '/exception'
         expect(last_response.body).to eq('message: rain! @backtrace')
@@ -1746,7 +1917,7 @@ XML
         it 'returns a custom error format' do
           subject.rescue_from :all, backtrace: true
           subject.error_formatter :txt, with: ApiSpec::CustomErrorFormatter
-          subject.get('/exception') { fail 'rain!' }
+          subject.get('/exception') { raise 'rain!' }
 
           get '/exception'
           expect(last_response.body).to eq('message: rain! @backtrace')
@@ -1758,7 +1929,7 @@ XML
       subject.rescue_from :all
       subject.format :json
       subject.get '/exception' do
-        fail 'rain!'
+        raise 'rain!'
       end
       get '/exception'
       expect(last_response.body).to eql '{"error":"rain!"}'
@@ -1767,7 +1938,7 @@ XML
       subject.rescue_from :all, backtrace: true
       subject.format :json
       subject.get '/exception' do
-        fail 'rain!'
+        raise 'rain!'
       end
       get '/exception'
       json = MultiJson.load(last_response.body)
@@ -1995,7 +2166,7 @@ XML
       subject.rescue_from :all
       subject.default_error_status 200
       subject.get '/exception' do
-        fail 'rain!'
+        raise 'rain!'
       end
       get '/exception'
       expect(last_response.status).to eql 200
@@ -2003,7 +2174,7 @@ XML
     it 'has a default error status' do
       subject.rescue_from :all
       subject.get '/exception' do
-        fail 'rain!'
+        raise 'rain!'
       end
       get '/exception'
       expect(last_response.status).to eql 500
@@ -2135,9 +2306,9 @@ XML
         expect(last_response.body).to eq('["a","b,c"]')
       end
       it 'sets params' do
-        expect(subject.routes.map { |route|
+        expect(subject.routes.map do |route|
           { params: route.params }
-        }).to eq [
+        end).to eq [
           {
             params: {
               'string' => '',
@@ -2165,9 +2336,9 @@ XML
         end
       end
       it 'sets params' do
-        expect(subject.routes.map { |route|
+        expect(subject.routes.map do |route|
           { params: route.params }
-        }).to eq [
+        end).to eq [
           {
             params: {
               'one' => { required: true, desc: 'a token' },
@@ -2196,9 +2367,9 @@ XML
         end
       end
       it 'sets params' do
-        expect(subject.routes.map { |route|
+        expect(subject.routes.map do |route|
           { params: route.params }
-        }).to eq [
+        end).to eq [
           {
             params: {
               'one' => { required: true, desc: 'a token' },
@@ -2250,7 +2421,7 @@ XML
     end
     it 'describes a method' do
       subject.desc 'first method'
-      subject.get :first do; end
+      subject.get :first
       expect(subject.routes.length).to eq(1)
       route = subject.routes.first
       expect(route.description).to eq('first method')
@@ -2260,31 +2431,31 @@ XML
     end
     it 'has params which does not include format and version as named captures' do
       subject.version :v1, using: :path
-      subject.get :first do; end
+      subject.get :first
       param_keys = subject.routes.first.params.keys
       expect(param_keys).not_to include('format')
       expect(param_keys).not_to include('version')
     end
     it 'describes methods separately' do
       subject.desc 'first method'
-      subject.get :first do; end
+      subject.get :first
       subject.desc 'second method'
-      subject.get :second do; end
+      subject.get :second
       expect(subject.routes.count).to eq(2)
-      expect(subject.routes.map { |route|
+      expect(subject.routes.map do |route|
         { description: route.description, params: route.params }
-      }).to eq [
+      end).to eq [
         { description: 'first method', params: {} },
         { description: 'second method', params: {} }
       ]
     end
     it 'resets desc' do
       subject.desc 'first method'
-      subject.get :first do; end
-      subject.get :second do; end
-      expect(subject.routes.map { |route|
+      subject.get :first
+      subject.get :second
+      expect(subject.routes.map do |route|
         { description: route.description, params: route.params }
-      }).to eq [
+      end).to eq [
         { description: 'first method', params: {} },
         { description: nil, params: {} }
       ]
@@ -2292,20 +2463,20 @@ XML
     it 'namespaces and describe arbitrary parameters' do
       subject.namespace 'ns' do
         desc 'ns second', foo: 'bar'
-        get 'second' do; end
+        get 'second'
       end
-      expect(subject.routes.map { |route|
+      expect(subject.routes.map do |route|
         { description: route.description, foo: route.route_foo, params: route.params }
-      }).to eq [
+      end).to eq [
         { description: 'ns second', foo: 'bar', params: {} }
       ]
     end
     it 'includes details' do
       subject.desc 'method', details: 'method details'
-      subject.get 'method' do; end
-      expect(subject.routes.map { |route|
+      subject.get 'method'
+      expect(subject.routes.map do |route|
         { description: route.description, details: route.details, params: route.params }
-      }).to eq [
+      end).to eq [
         { description: 'method', details: 'method details', params: {} }
       ]
     end
@@ -2314,9 +2485,9 @@ XML
       subject.get 'reverse' do
         params[:s].reverse
       end
-      expect(subject.routes.map { |route|
+      expect(subject.routes.map do |route|
         { description: route.description, params: route.params }
-      }).to eq [
+      end).to eq [
         { description: 'Reverses a string.', params: { 's' => { desc: 'string to reverse', type: 'string' } } }
       ]
     end
@@ -2327,17 +2498,17 @@ XML
         optional :param2
       end
       subject.namespace 'ns1' do
-        get do; end
+        get { ; }
       end
       subject.params do
         optional :param2
       end
       subject.namespace 'ns2' do
-        get do; end
+        get { ; }
       end
-      routes_doc = subject.routes.map { |route|
+      routes_doc = subject.routes.map do |route|
         { description: route.description, params: route.params }
-      }
+      end
       expect(routes_doc).to eq [
         { description: 'global description',
           params: {
@@ -2362,12 +2533,12 @@ XML
         params do
           optional :method_param, desc: 'method parameter'
         end
-        get 'method' do; end
+        get 'method'
       end
 
-      routes_doc = subject.routes.map { |route|
+      routes_doc = subject.routes.map do |route|
         { description: route.description, params: route.params }
-      }
+      end
       expect(routes_doc).to eq [
         { description: 'method',
           params: {
@@ -2394,12 +2565,12 @@ XML
           params do
             optional :method_param, desc: 'method param'
           end
-          get 'method' do; end
+          get 'method'
         end
       end
-      expect(subject.routes.map { |route|
+      expect(subject.routes.map do |route|
         { description: route.description, params: route.params }
-      }).to eq [
+      end).to eq [
         { description: 'method',
           params: {
             'ns_param' => { required: true, desc: 'ns param 2' },
@@ -2422,7 +2593,7 @@ XML
           requires :param2, desc: 'group2 param2 desc'
         end
       end
-      subject.get 'method' do; end
+      subject.get 'method'
 
       expect(subject.routes.map(&:params)).to eq [{
         'group1'         => { required: true, type: 'Array' },
@@ -2441,10 +2612,10 @@ XML
           requires :nested_param, desc: 'nested param'
         end
       end
-      subject.get 'method' do; end
-      expect(subject.routes.map { |route|
+      subject.get 'method'
+      expect(subject.routes.map do |route|
         { description: route.description, params: route.params }
-      }).to eq [
+      end).to eq [
         { description: 'nesting',
           params: {
             'root_param' => { required: true, desc: 'root param' },
@@ -2465,10 +2636,10 @@ XML
       subject.params do
         requires :one_param, desc: 'one param'
       end
-      subject.get 'method' do; end
-      expect(subject.routes.map { |route|
+      subject.get 'method'
+      expect(subject.routes.map do |route|
         { description: route.description, params: route.params }
-      }).to eq [
+      end).to eq [
         { description: nil, params: { 'one_param' => { required: true, desc: 'one param' } } }
       ]
     end
@@ -2477,9 +2648,9 @@ XML
       subject.get 'reverse/:s' do
         params[:s].reverse
       end
-      expect(subject.routes.map { |route|
+      expect(subject.routes.map do |route|
         { description: route.description, params: route.params }
-      }).to eq [
+      end).to eq [
         { description: 'Reverses a string.', params: { 's' => { desc: 'string to reverse', type: 'string' } } }
       ]
     end
@@ -2560,22 +2731,78 @@ XML
         expect(last_response.body).to eq('yo')
       end
 
-      it 'inherits rescues even when some defined by mounted' do
-        subject.rescue_from :all do |e|
-          rack_response("rescued from #{e.message}", 202)
+      context 'when some rescues are defined by mounted' do
+        it 'inherits parent rescues' do
+          subject.rescue_from :all do |e|
+            rack_response("rescued from #{e.message}", 202)
+          end
+
+          app = Class.new(Grape::API)
+
+          subject.namespace :mounted do
+            app.rescue_from ArgumentError
+            app.get('/fail') { raise 'doh!' }
+            mount app
+          end
+
+          get '/mounted/fail'
+          expect(last_response.status).to eql 202
+          expect(last_response.body).to eq('rescued from doh!')
         end
+        it 'prefers rescues defined by mounted if they rescue similar error class' do
+          subject.rescue_from StandardError do
+            rack_response('outer rescue')
+          end
 
-        app = Class.new(Grape::API)
+          app = Class.new(Grape::API)
 
-        subject.namespace :mounted do
-          app.rescue_from ArgumentError
-          app.get('/fail') { fail 'doh!' }
-          mount app
+          subject.namespace :mounted do
+            rescue_from StandardError do
+              rack_response('inner rescue')
+            end
+            app.get('/fail') { raise 'doh!' }
+            mount app
+          end
+
+          get '/mounted/fail'
+          expect(last_response.body).to eq('inner rescue')
         end
+        it 'prefers rescues defined by mounted even if outer is more specific' do
+          subject.rescue_from ArgumentError do
+            rack_response('outer rescue')
+          end
+
+          app = Class.new(Grape::API)
+
+          subject.namespace :mounted do
+            rescue_from StandardError do
+              rack_response('inner rescue')
+            end
+            app.get('/fail') { raise ArgumentError.new }
+            mount app
+          end
 
-        get '/mounted/fail'
-        expect(last_response.status).to eql 202
-        expect(last_response.body).to eq('rescued from doh!')
+          get '/mounted/fail'
+          expect(last_response.body).to eq('inner rescue')
+        end
+        it 'prefers more specific rescues defined by mounted' do
+          subject.rescue_from StandardError do
+            rack_response('outer rescue')
+          end
+
+          app = Class.new(Grape::API)
+
+          subject.namespace :mounted do
+            rescue_from ArgumentError do
+              rack_response('inner rescue')
+            end
+            app.get('/fail') { raise ArgumentError.new }
+            mount app
+          end
+
+          get '/mounted/fail'
+          expect(last_response.body).to eq('inner rescue')
+        end
       end
 
       it 'collects the routes of the mounted api' do