grape 1.0.0 → 1.6.0

data/spec/grape/middleware/exception_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Middleware::Error do
@@ -11,6 +13,15 @@ describe Grape::Middleware::Error do
       end
     end
 
+    # raises a non-StandardError (ScriptError) exception
+    class OtherExceptionApp
+      class << self
+        def call(_env)
+          raise NotImplementedError, 'snow!'
+        end
+      end
+    end
+
     # raises a hash error
     class ErrorHashApp
       class << self
@@ -44,153 +55,292 @@ describe Grape::Middleware::Error do
     class CustomErrorApp
       class << self
         def call(_env)
-          raise CustomError, status: 400, message: 'failed validation'
+          raise CustomError.new(status: 400, message: 'failed validation')
         end
       end
     end
   end
 
-  attr_reader :app
-
-  it 'does not trap errors by default' do
-    @app ||= Rack::Builder.app do
-      use Spec::Support::EndpointFaker
-      use Grape::Middleware::Error
-      run ExceptionSpec::ExceptionApp
-    end
-    expect { get '/' }.to raise_error(RuntimeError, 'rain!')
+  def app
+    subject
   end
 
-  context 'with rescue_all set to true' do
-    it 'sets the message appropriately' do
-      @app ||= Rack::Builder.app do
+  context 'with defaults' do
+    subject do
+      Rack::Builder.app do
         use Spec::Support::EndpointFaker
-        use Grape::Middleware::Error, rescue_all: true
+        use Grape::Middleware::Error
         run ExceptionSpec::ExceptionApp
       end
-      get '/'
-      expect(last_response.body).to eq('rain!')
     end
+    it 'does not trap errors by default' do
+      expect { get '/' }.to raise_error(RuntimeError, 'rain!')
+    end
+  end
 
-    it 'defaults to a 500 status' do
-      @app ||= Rack::Builder.app do
-        use Spec::Support::EndpointFaker
-        use Grape::Middleware::Error, rescue_all: true
-        run ExceptionSpec::ExceptionApp
+  context 'with rescue_all' do
+    context 'StandardError exception' do
+      subject do
+        Rack::Builder.app do
+          use Spec::Support::EndpointFaker
+          use Grape::Middleware::Error, rescue_all: true
+          run ExceptionSpec::ExceptionApp
+        end
+      end
+      it 'sets the message appropriately' do
+        get '/'
+        expect(last_response.body).to eq('rain!')
+      end
+      it 'defaults to a 500 status' do
+        get '/'
+        expect(last_response.status).to eq(500)
       end
-      get '/'
-      expect(last_response.status).to eq(500)
     end
 
-    it 'is possible to specify a different default status code' do
-      @app ||= Rack::Builder.app do
+    context 'Non-StandardError exception' do
+      subject do
+        Rack::Builder.app do
+          use Spec::Support::EndpointFaker
+          use Grape::Middleware::Error, rescue_all: true
+          run ExceptionSpec::OtherExceptionApp
+        end
+      end
+      it 'does not trap errors other than StandardError' do
+        expect { get '/' }.to raise_error(NotImplementedError, 'snow!')
+      end
+    end
+  end
+
+  context 'Non-StandardError exception with a provided rescue handler' do
+    context 'default error response' do
+      subject do
+        Rack::Builder.app do
+          use Spec::Support::EndpointFaker
+          use Grape::Middleware::Error, rescue_handlers: { NotImplementedError => nil }
+          run ExceptionSpec::OtherExceptionApp
+        end
+      end
+      it 'rescues the exception using the default handler' do
+        get '/'
+        expect(last_response.body).to eq('snow!')
+      end
+    end
+
+    context 'custom error response' do
+      subject do
+        Rack::Builder.app do
+          use Spec::Support::EndpointFaker
+          use Grape::Middleware::Error, rescue_handlers: { NotImplementedError => -> { Rack::Response.new('rescued', 200, {}) } }
+          run ExceptionSpec::OtherExceptionApp
+        end
+      end
+      it 'rescues the exception using the provided handler' do
+        get '/'
+        expect(last_response.body).to eq('rescued')
+      end
+    end
+  end
+
+  context do
+    subject do
+      Rack::Builder.app do
         use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: true, default_status: 500
         run ExceptionSpec::ExceptionApp
       end
+    end
+    it 'is possible to specify a different default status code' do
       get '/'
       expect(last_response.status).to eq(500)
     end
+  end
 
-    it 'is possible to return errors in json format' do
-      @app ||= Rack::Builder.app do
+  context do
+    subject do
+      Rack::Builder.app do
         use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: true, format: :json
         run ExceptionSpec::ExceptionApp
       end
+    end
+    it 'is possible to return errors in json format' do
       get '/'
       expect(last_response.body).to eq('{"error":"rain!"}')
     end
+  end
 
-    it 'is possible to return hash errors in json format' do
-      @app ||= Rack::Builder.app do
+  context do
+    subject do
+      Rack::Builder.app do
         use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: true, format: :json
         run ExceptionSpec::ErrorHashApp
       end
+    end
+    it 'is possible to return hash errors in json format' do
       get '/'
       expect(['{"error":"rain!","detail":"missing widget"}',
               '{"detail":"missing widget","error":"rain!"}']).to include(last_response.body)
     end
+  end
 
-    it 'is possible to return errors in jsonapi format' do
-      @app ||= Rack::Builder.app do
+  context do
+    subject do
+      Rack::Builder.app do
         use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: true, format: :jsonapi
         run ExceptionSpec::ExceptionApp
       end
+    end
+    it 'is possible to return errors in jsonapi format' do
       get '/'
-      expect(last_response.body).to eq('{"error":"rain!"}')
+      expect(last_response.body).to eq('{&quot;error&quot;:&quot;rain!&quot;}')
     end
+  end
 
-    it 'is possible to return hash errors in jsonapi format' do
-      @app ||= Rack::Builder.app do
+  context do
+    subject do
+      Rack::Builder.app do
         use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: true, format: :jsonapi
         run ExceptionSpec::ErrorHashApp
       end
+    end
+
+    it 'is possible to return hash errors in jsonapi format' do
       get '/'
-      expect(['{"error":"rain!","detail":"missing widget"}',
-              '{"detail":"missing widget","error":"rain!"}']).to include(last_response.body)
+      expect(['{&quot;error&quot;:&quot;rain!&quot;,&quot;detail&quot;:&quot;missing widget&quot;}',
+              '{&quot;detail&quot;:&quot;missing widget&quot;,&quot;error&quot;:&quot;rain!&quot;}']).to include(last_response.body)
     end
+  end
 
-    it 'is possible to return errors in xml format' do
-      @app ||= Rack::Builder.app do
+  context do
+    subject do
+      Rack::Builder.app do
         use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: true, format: :xml
         run ExceptionSpec::ExceptionApp
       end
+    end
+    it 'is possible to return errors in xml format' do
       get '/'
       expect(last_response.body).to eq("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<error>\n  <message>rain!</message>\n</error>\n")
     end
+  end
 
-    it 'is possible to return hash errors in xml format' do
-      @app ||= Rack::Builder.app do
+  context do
+    subject do
+      Rack::Builder.app do
         use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: true, format: :xml
         run ExceptionSpec::ErrorHashApp
       end
+    end
+    it 'is possible to return hash errors in xml format' do
       get '/'
       expect(["<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<error>\n  <detail>missing widget</detail>\n  <error>rain!</error>\n</error>\n",
               "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<error>\n  <error>rain!</error>\n  <detail>missing widget</detail>\n</error>\n"]).to include(last_response.body)
     end
+  end
 
-    it 'is possible to specify a custom formatter' do
-      @app ||= Rack::Builder.app do
+  context do
+    subject do
+      Rack::Builder.app do
         use Spec::Support::EndpointFaker
-        use Grape::Middleware::Error, rescue_all: true,
-                                      format: :custom,
-                                      error_formatters: {
-                                        custom: lambda do |message, _backtrace, _options, _env|
-                                          { custom_formatter: message }.inspect
-                                        end
-                                      }
+        use Grape::Middleware::Error,
+            rescue_all: true,
+            format: :custom,
+            error_formatters: {
+              custom: lambda do |message, _backtrace, _options, _env, _original_exception|
+                { custom_formatter: message }.inspect
+              end
+            }
         run ExceptionSpec::ExceptionApp
       end
+    end
+    it 'is possible to specify a custom formatter' do
       get '/'
-      expect(last_response.body).to eq('{:custom_formatter=>"rain!"}')
+      expect(last_response.body).to eq('{:custom_formatter=&gt;&quot;rain!&quot;}')
     end
+  end
 
-    it 'does not trap regular error! codes' do
-      @app ||= Rack::Builder.app do
+  context do
+    subject do
+      Rack::Builder.app do
         use Spec::Support::EndpointFaker
         use Grape::Middleware::Error
         run ExceptionSpec::AccessDeniedApp
       end
+    end
+    it 'does not trap regular error! codes' do
       get '/'
       expect(last_response.status).to eq(401)
     end
+  end
 
-    it 'responds to custom Grape exceptions appropriately' do
-      @app ||= Rack::Builder.app do
+  context do
+    subject do
+      Rack::Builder.app do
         use Spec::Support::EndpointFaker
         use Grape::Middleware::Error, rescue_all: false
         run ExceptionSpec::CustomErrorApp
       end
-
+    end
+    it 'responds to custom Grape exceptions appropriately' do
       get '/'
       expect(last_response.status).to eq(400)
       expect(last_response.body).to eq('failed validation')
     end
   end
+
+  context 'with rescue_options :backtrace and :exception set to true' do
+    subject do
+      Rack::Builder.app do
+        use Spec::Support::EndpointFaker
+        use Grape::Middleware::Error,
+            rescue_all: true,
+            format: :json,
+            rescue_options: { backtrace: true, original_exception: true }
+        run ExceptionSpec::ExceptionApp
+      end
+    end
+    it 'is possible to return the backtrace and the original exception in json format' do
+      get '/'
+      expect(last_response.body).to include('error', 'rain!', 'backtrace', 'original_exception', 'RuntimeError')
+    end
+  end
+
+  context do
+    subject do
+      Rack::Builder.app do
+        use Spec::Support::EndpointFaker
+        use Grape::Middleware::Error,
+            rescue_all: true,
+            format: :xml,
+            rescue_options: { backtrace: true, original_exception: true }
+        run ExceptionSpec::ExceptionApp
+      end
+    end
+    it 'is possible to return the backtrace and the original exception in xml format' do
+      get '/'
+      expect(last_response.body).to include('error', 'rain!', 'backtrace', 'original-exception', 'RuntimeError')
+    end
+  end
+
+  context do
+    subject do
+      Rack::Builder.app do
+        use Spec::Support::EndpointFaker
+        use Grape::Middleware::Error,
+            rescue_all: true,
+            format: :txt,
+            rescue_options: { backtrace: true, original_exception: true }
+        run ExceptionSpec::ExceptionApp
+      end
+    end
+    it 'is possible to return the backtrace and the original exception in txt format' do
+      get '/'
+      expect(last_response.body).to include('error', 'rain!', 'backtrace', 'original exception', 'RuntimeError')
+    end
+  end
 end

data/spec/grape/middleware/formatter_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Middleware::Formatter do
@@ -18,7 +20,7 @@ describe Grape::Middleware::Formatter do
       let(:body) { ['foo'] }
       it 'calls #to_json since default format is json' do
         body.instance_eval do
-          def to_json
+          def to_json(*_args)
             '"bar"'
           end
         end
@@ -31,7 +33,7 @@ describe Grape::Middleware::Formatter do
       let(:body) { { 'foos' => [{ 'bar' => 'baz' }] } }
       it 'calls #to_json if the content type is jsonapi' do
         body.instance_eval do
-          def to_json
+          def to_json(*_args)
             '{"foos":[{"bar":"baz"}] }'
           end
         end
@@ -41,7 +43,7 @@ describe Grape::Middleware::Formatter do
     end
 
     context 'xml' do
-      let(:body) { 'string' }
+      let(:body) { +'string' }
       it 'calls #to_xml if the content type is xml' do
         body.instance_eval do
           def to_xml
@@ -194,26 +196,32 @@ describe Grape::Middleware::Formatter do
       subject.options[:content_types][:custom] = "don't care"
       subject.options[:formatters][:custom] = ->(_obj, _env) { 'CUSTOM FORMAT' }
       _, _, body = subject.call('PATH_INFO' => '/info.custom')
-      expect(body.body).to eq(['CUSTOM FORMAT'])
+      expect(read_chunks(body)).to eq(['CUSTOM FORMAT'])
     end
     context 'default' do
       let(:body) { ['blah'] }
       it 'uses default json formatter' do
         _, _, body = subject.call('PATH_INFO' => '/info.json')
-        expect(body.body).to eq(['["blah"]'])
+        expect(read_chunks(body)).to eq(['["blah"]'])
       end
     end
     it 'uses custom json formatter' do
       subject.options[:formatters][:json] = ->(_obj, _env) { 'CUSTOM JSON FORMAT' }
       _, _, body = subject.call('PATH_INFO' => '/info.json')
-      expect(body.body).to eq(['CUSTOM JSON FORMAT'])
+      expect(read_chunks(body)).to eq(['CUSTOM JSON FORMAT'])
     end
   end
 
   context 'no content responses' do
     let(:no_content_response) { ->(status) { [status, {}, ['']] } }
 
-    Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.each do |status|
+    STATUSES_WITHOUT_BODY = if Gem::Version.new(Rack.release) >= Gem::Version.new('2.1.0')
+                              Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.keys
+                            else
+                              Rack::Utils::STATUS_WITH_NO_ENTITY_BODY
+                            end
+
+    STATUSES_WITHOUT_BODY.each do |status|
       it "does not modify a #{status} response" do
         expected_response = no_content_response[status]
         allow(app).to receive(:call).and_return(expected_response)
@@ -223,7 +231,81 @@ describe Grape::Middleware::Formatter do
   end
 
   context 'input' do
-    %w(POST PATCH PUT DELETE).each do |method|
+    %w[POST PATCH PUT DELETE].each do |method|
+      context 'when body is not nil or empty' do
+        context 'when Content-Type is supported' do
+          let(:io) { StringIO.new('{"is_boolean":true,"string":"thing"}') }
+          let(:content_type) { 'application/json' }
+
+          it "parses the body from #{method} and copies values into rack.request.form_hash" do
+            subject.call(
+              'PATH_INFO' => '/info',
+              'REQUEST_METHOD' => method,
+              'CONTENT_TYPE' => content_type,
+              'rack.input' => io,
+              'CONTENT_LENGTH' => io.length
+            )
+            expect(subject.env['rack.request.form_hash']['is_boolean']).to be true
+            expect(subject.env['rack.request.form_hash']['string']).to eq('thing')
+          end
+        end
+
+        context 'when Content-Type is not supported' do
+          let(:io) { StringIO.new('{"is_boolean":true,"string":"thing"}') }
+          let(:content_type) { 'application/atom+xml' }
+
+          it 'returns a 415 HTTP error status' do
+            error = catch(:error) do
+              subject.call(
+                'PATH_INFO' => '/info',
+                'REQUEST_METHOD' => method,
+                'CONTENT_TYPE' => content_type,
+                'rack.input' => io,
+                'CONTENT_LENGTH' => io.length
+              )
+            end
+            expect(error[:status]).to eq(415)
+            expect(error[:message]).to eq("The provided content-type 'application/atom+xml' is not supported.")
+          end
+        end
+      end
+
+      context 'when body is nil' do
+        let(:io) { double }
+        before do
+          allow(io).to receive_message_chain(:rewind, :read).and_return(nil)
+        end
+
+        it 'does not read and parse the body' do
+          expect(subject).not_to receive(:read_rack_input)
+          subject.call(
+            'PATH_INFO' => '/info',
+            'REQUEST_METHOD' => method,
+            'CONTENT_TYPE' => 'application/json',
+            'rack.input' => io,
+            'CONTENT_LENGTH' => 0
+          )
+        end
+      end
+
+      context 'when body is empty' do
+        let(:io) { double }
+        before do
+          allow(io).to receive_message_chain(:rewind, :read).and_return('')
+        end
+
+        it 'does not read and parse the body' do
+          expect(subject).not_to receive(:read_rack_input)
+          subject.call(
+            'PATH_INFO' => '/info',
+            'REQUEST_METHOD' => method,
+            'CONTENT_TYPE' => 'application/json',
+            'rack.input' => io,
+            'CONTENT_LENGTH' => 0
+          )
+        end
+      end
+
       ['application/json', 'application/json; charset=utf-8'].each do |content_type|
         context content_type do
           it "parses the body from #{method} and copies values into rack.request.form_hash" do
@@ -297,12 +379,17 @@ describe Grape::Middleware::Formatter do
   end
 
   context 'send file' do
-    let(:body) { Grape::ServeFile::FileResponse.new('file') }
-    let(:app) { ->(_env) { [200, {}, body] } }
+    let(:file) { double(File) }
+    let(:file_body) { Grape::ServeStream::StreamResponse.new(file) }
+    let(:app) { ->(_env) { [200, {}, file_body] } }
 
-    it 'returns Grape::Uril::SendFileReponse' do
+    it 'returns a file response' do
+      expect(file).to receive(:each).and_yield('data')
       env = { 'PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json' }
-      expect(subject.call(env)).to be_a(Grape::ServeFile::SendfileResponse)
+      status, headers, body = subject.call(env)
+      expect(status).to be == 200
+      expect(headers).to be == { 'Content-Type' => 'application/json' }
+      expect(read_chunks(body)).to be == ['data']
     end
   end
 
@@ -315,13 +402,41 @@ describe Grape::Middleware::Formatter do
     let(:app) { ->(_env) { [200, {}, ['']] } }
     before do
       Grape::Formatter.register :invalid, InvalidFormatter
-      Grape::ContentTypes::CONTENT_TYPES[:invalid] = 'application/x-invalid'
+      Grape::ContentTypes.register :invalid, 'application/x-invalid'
+    end
+    after do
+      Grape::ContentTypes.default_elements.delete(:invalid)
+      Grape::Formatter.default_elements.delete(:invalid)
     end
 
     it 'returns response by invalid formatter' do
       env = { 'PATH_INFO' => '/hello.invalid', 'HTTP_ACCEPT' => 'application/x-invalid' }
-      _, _, bodies = *subject.call(env)
-      expect(bodies.body.first).to eq({ message: 'invalid' }.to_json)
+      _, _, body = *subject.call(env)
+      expect(read_chunks(body).join).to eq({ message: 'invalid' }.to_json)
+    end
+  end
+
+  context 'custom parser raises exception and rescue options are enabled for backtrace and original_exception' do
+    it 'adds the backtrace and original_exception to the error output' do
+      subject = Grape::Middleware::Formatter.new(
+        app,
+        rescue_options: { backtrace: true, original_exception: true },
+        parsers: { json: ->(_object, _env) { raise StandardError, 'fail' } }
+      )
+      io = StringIO.new('{invalid}')
+      error = catch(:error) do
+        subject.call(
+          'PATH_INFO' => '/info',
+          'REQUEST_METHOD' => 'POST',
+          'CONTENT_TYPE' => 'application/json',
+          'rack.input' => io,
+          'CONTENT_LENGTH' => io.length
+        )
+      end
+
+      expect(error[:message]).to eq 'fail'
+      expect(error[:backtrace].size).to be >= 1
+      expect(error[:original_exception].class).to eq StandardError
     end
   end
 end

data/spec/grape/middleware/globals_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Middleware::Globals do

data/spec/grape/middleware/stack_spec.rb

@@ -1,18 +1,23 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Middleware::Stack do
   module StackSpec
     class FooMiddleware; end
+
     class BarMiddleware; end
+
     class BlockMiddleware
       attr_reader :block
+
       def initialize(&block)
         @block = block
       end
     end
   end
 
-  let(:proc) { ->() {} }
+  let(:proc) { -> {} }
   let(:others) { [[:use, StackSpec::BarMiddleware], [:insert_before, StackSpec::BarMiddleware, StackSpec::BlockMiddleware, proc]] }
 
   subject { Grape::Middleware::Stack.new }
@@ -109,6 +114,15 @@ describe Grape::Middleware::Stack do
       expect(subject[1]).to eq(StackSpec::BlockMiddleware)
       expect(subject[2]).to eq(StackSpec::BarMiddleware)
     end
+
+    context 'middleware spec with proc declaration exists' do
+      let(:middleware_spec_with_proc) { [:use, StackSpec::FooMiddleware, proc] }
+
+      it 'properly forwards spec arguments' do
+        expect(subject).to receive(:use).with(StackSpec::FooMiddleware)
+        subject.merge_with([middleware_spec_with_proc])
+      end
+    end
   end
 
   describe '#build' do

data/spec/grape/middleware/versioner/accept_version_header_spec.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Middleware::Versioner::AcceptVersionHeader do
   let(:app) { ->(env) { [200, env, env] } }
-  subject { Grape::Middleware::Versioner::AcceptVersionHeader.new(app, @options || {}) }
+  subject { Grape::Middleware::Versioner::AcceptVersionHeader.new(app, **(@options || {})) }
 
   before do
     @options = {

data/spec/grape/middleware/versioner/header_spec.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Middleware::Versioner::Header do
   let(:app) { ->(env) { [200, env, env] } }
-  subject { Grape::Middleware::Versioner::Header.new(app, @options || {}) }
+  subject { Grape::Middleware::Versioner::Header.new(app, **(@options || {})) }
 
   before do
     @options = {
@@ -160,6 +162,12 @@ describe Grape::Middleware::Versioner::Header do
     expect(subject.call({}).first).to eq(200)
   end
 
+  it 'succeeds if :strict is set to false and given an invalid header' do
+    @options[:version_options][:strict] = false
+    expect(subject.call('HTTP_ACCEPT' => 'yaml').first).to eq(200)
+    expect(subject.call({}).first).to eq(200)
+  end
+
   context 'when :strict is set' do
     before do
       @options[:versions] = ['v1']
@@ -241,7 +249,7 @@ describe Grape::Middleware::Versioner::Header do
 
   context 'when multiple versions are specified' do
     before do
-      @options[:versions] = %w(v1 v2)
+      @options[:versions] = %w[v1 v2]
     end
 
     it 'succeeds with v1' do