grape 1.8.0 → 4.0.1

data/spec/grape/middleware/base_spec.rb

@@ -1,221 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Middleware::Base do
-  subject { described_class.new(blank_app) }
-
-  let(:blank_app) { ->(_) { [200, {}, 'Hi there.'] } }
-
-  before do
-    # Keep it one object for testing.
-    allow(subject).to receive(:dup).and_return(subject)
-  end
-
-  it 'has the app as an accessor' do
-    expect(subject.app).to eq(blank_app)
-  end
-
-  it 'calls through to the app' do
-    expect(subject.call({})).to eq([200, {}, 'Hi there.'])
-  end
-
-  context 'callbacks' do
-    after { subject.call!({}) }
-
-    it 'calls #before' do
-      expect(subject).to receive(:before)
-    end
-
-    it 'calls #after' do
-      expect(subject).to receive(:after)
-    end
-  end
-
-  context 'callbacks on error' do
-    let(:blank_app) { ->(_) { raise StandardError } }
-
-    it 'calls #after' do
-      expect(subject).to receive(:after)
-      expect { subject.call({}) }.to raise_error(StandardError)
-    end
-  end
-
-  context 'after callback' do
-    before do
-      allow(subject).to receive(:after).and_return([200, {}, 'Hello from after callback'])
-    end
-
-    it 'overwrites application response' do
-      expect(subject.call!({}).last).to eq('Hello from after callback')
-    end
-  end
-
-  context 'after callback with errors' do
-    it 'does not overwrite the application response' do
-      expect(subject.call({})).to eq([200, {}, 'Hi there.'])
-    end
-
-    context 'with patched warnings' do
-      before do
-        @warnings = warnings = []
-        allow_any_instance_of(described_class).to receive(:warn) { |m| warnings << m }
-        allow(subject).to receive(:after).and_raise(StandardError)
-      end
-
-      it 'does show a warning' do
-        expect { subject.call({}) }.to raise_error(StandardError)
-        expect(@warnings).not_to be_empty
-      end
-    end
-  end
-
-  it 'is able to access the response' do
-    subject.call({})
-    expect(subject.response).to be_a(Rack::Response)
-  end
-
-  describe '#response' do
-    subject do
-      described_class.new(response)
-    end
-
-    before { subject.call({}) }
-
-    context 'when Array' do
-      let(:rack_response) { Rack::Response.new('test', 204, abc: 1) }
-      let(:response) { ->(_) { [204, { abc: 1 }, 'test'] } }
-
-      it 'status' do
-        expect(subject.response.status).to eq(204)
-      end
-
-      it 'body' do
-        expect(subject.response.body).to eq(['test'])
-      end
-
-      it 'header' do
-        expect(subject.response.header).to have_key(:abc)
-      end
-
-      it 'returns the memoized Rack::Response instance' do
-        allow(Rack::Response).to receive(:new).and_return(rack_response)
-        expect(subject.response).to eq(rack_response)
-      end
-    end
-
-    context 'when Rack::Response' do
-      let(:rack_response) { Rack::Response.new('test', 204, abc: 1) }
-      let(:response) { ->(_) { rack_response } }
-
-      it 'status' do
-        expect(subject.response.status).to eq(204)
-      end
-
-      it 'body' do
-        expect(subject.response.body).to eq(['test'])
-      end
-
-      it 'header' do
-        expect(subject.response.header).to have_key(:abc)
-      end
-
-      it 'returns the memoized Rack::Response instance' do
-        expect(subject.response).to eq(rack_response)
-      end
-    end
-  end
-
-  describe '#context' do
-    subject { described_class.new(blank_app) }
-
-    it 'allows access to response context' do
-      subject.call(Grape::Env::API_ENDPOINT => { header: 'some header' })
-      expect(subject.context).to eq(header: 'some header')
-    end
-  end
-
-  context 'options' do
-    it 'persists options passed at initialization' do
-      expect(described_class.new(blank_app, abc: true).options[:abc]).to be true
-    end
-
-    context 'defaults' do
-      module BaseSpec
-        class ExampleWare < Grape::Middleware::Base
-          def default_options
-            { monkey: true }
-          end
-        end
-      end
-
-      it 'persists the default options' do
-        expect(BaseSpec::ExampleWare.new(blank_app).options[:monkey]).to be true
-      end
-
-      it 'overrides default options when provided' do
-        expect(BaseSpec::ExampleWare.new(blank_app, monkey: false).options[:monkey]).to be false
-      end
-    end
-  end
-
-  context 'header' do
-    module HeaderSpec
-      class ExampleWare < Grape::Middleware::Base
-        def before
-          header 'X-Test-Before', 'Hi'
-        end
-
-        def after
-          header 'X-Test-After', 'Bye'
-          nil
-        end
-      end
-    end
-
-    def app
-      Rack::Builder.app do
-        use HeaderSpec::ExampleWare
-        run ->(_) { [200, {}, ['Yeah']] }
-      end
-    end
-
-    it 'is able to set a header' do
-      get '/'
-      expect(last_response.headers['X-Test-Before']).to eq('Hi')
-      expect(last_response.headers['X-Test-After']).to eq('Bye')
-    end
-  end
-
-  context 'header overwrite' do
-    module HeaderOverwritingSpec
-      class ExampleWare < Grape::Middleware::Base
-        def before
-          header 'X-Test-Overwriting', 'Hi'
-        end
-
-        def after
-          header 'X-Test-Overwriting', 'Bye'
-          nil
-        end
-      end
-
-      class API < Grape::API
-        get('/') do
-          header 'X-Test-Overwriting', 'Yeah'
-          'Hello'
-        end
-      end
-    end
-
-    def app
-      Rack::Builder.app do
-        use HeaderOverwritingSpec::ExampleWare
-        run HeaderOverwritingSpec::API.new
-      end
-    end
-
-    it 'overwrites header by after headers' do
-      get '/'
-      expect(last_response.headers['X-Test-Overwriting']).to eq('Bye')
-    end
-  end
-end

data/spec/grape/middleware/error_spec.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require 'grape-entity'
-
-describe Grape::Middleware::Error do
-  module ErrorSpec
-    class ErrorEntity < Grape::Entity
-      expose :code
-      expose :static
-
-      def static
-        'static text'
-      end
-    end
-
-    class ErrApp
-      class << self
-        attr_accessor :error, :format
-
-        def call(_env)
-          throw :error, error
-        end
-      end
-    end
-  end
-
-  def app
-    opts = options
-    Rack::Builder.app do
-      use Spec::Support::EndpointFaker
-      use Grape::Middleware::Error, **opts
-      run ErrorSpec::ErrApp
-    end
-  end
-
-  let(:options) { { default_message: 'Aww, hamburgers.' } }
-
-  it 'sets the status code appropriately' do
-    ErrorSpec::ErrApp.error = { status: 410 }
-    get '/'
-    expect(last_response.status).to eq(410)
-  end
-
-  it 'sets the status code based on the rack util status code symbol' do
-    ErrorSpec::ErrApp.error = { status: :gone }
-    get '/'
-    expect(last_response.status).to eq(410)
-  end
-
-  it 'sets the error message appropriately' do
-    ErrorSpec::ErrApp.error = { message: 'Awesome stuff.' }
-    get '/'
-    expect(last_response.body).to eq('Awesome stuff.')
-  end
-
-  it 'defaults to a 500 status' do
-    ErrorSpec::ErrApp.error = {}
-    get '/'
-    expect(last_response.status).to eq(500)
-  end
-
-  it 'has a default message' do
-    ErrorSpec::ErrApp.error = {}
-    get '/'
-    expect(last_response.body).to eq('Aww, hamburgers.')
-  end
-
-  context 'with http code' do
-    let(:options) {  { default_message: 'Aww, hamburgers.' } }
-
-    it 'adds the status code if wanted' do
-      ErrorSpec::ErrApp.error = { message: { code: 200 } }
-      get '/'
-
-      expect(last_response.body).to eq({ code: 200 }.to_json)
-    end
-
-    it 'presents an error message' do
-      ErrorSpec::ErrApp.error = { message: { code: 200, with: ErrorSpec::ErrorEntity } }
-      get '/'
-
-      expect(last_response.body).to eq({ code: 200, static: 'static text' }.to_json)
-    end
-  end
-end

data/spec/grape/middleware/exception_spec.rb

@@ -1,294 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Middleware::Error do
-  let(:exception_app) do
-    Class.new do
-      class << self
-        def call(_env)
-          raise 'rain!'
-        end
-      end
-    end
-  end
-
-  let(:other_exception_app) do
-    Class.new do
-      class << self
-        def call(_env)
-          raise NotImplementedError, 'snow!'
-        end
-      end
-    end
-  end
-
-  let(:custom_error_app) do
-    Class.new do
-      class << self
-        class CustomError < Grape::Exceptions::Base; end
-
-        def call(_env)
-          raise CustomError.new(status: 400, message: 'failed validation')
-        end
-      end
-    end
-  end
-
-  let(:error_hash_app) do
-    Class.new do
-      class << self
-        def error!(message, status)
-          throw :error, message: { error: message, detail: 'missing widget' }, status: status
-        end
-
-        def call(_env)
-          error!('rain!', 401)
-        end
-      end
-    end
-  end
-
-  let(:access_denied_app) do
-    Class.new do
-      class << self
-        def error!(message, status)
-          throw :error, message: message, status: status
-        end
-
-        def call(_env)
-          error!('Access Denied', 401)
-        end
-      end
-    end
-  end
-
-  let(:app) do
-    builder = Rack::Builder.new
-    builder.use Spec::Support::EndpointFaker
-    if options.any?
-      builder.use described_class, options
-    else
-      builder.use described_class
-    end
-    builder.run running_app
-    builder.to_app
-  end
-
-  context 'with defaults' do
-    let(:running_app) { exception_app }
-    let(:options) { {} }
-
-    it 'does not trap errors by default' do
-      expect { get '/' }.to raise_error(RuntimeError, 'rain!')
-    end
-  end
-
-  context 'with rescue_all' do
-    context 'StandardError exception' do
-      let(:running_app) { exception_app }
-      let(:options) { { rescue_all: true } }
-
-      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
-    end
-
-    context 'Non-StandardError exception' do
-      let(:running_app) { other_exception_app }
-      let(:options) { { rescue_all: true } }
-
-      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
-      let(:running_app) { other_exception_app }
-      let(:options) { { rescue_handlers: { NotImplementedError => nil } } }
-
-      it 'rescues the exception using the default handler' do
-        get '/'
-        expect(last_response.body).to eq('snow!')
-      end
-    end
-
-    context 'custom error response' do
-      let(:running_app) { other_exception_app }
-      let(:options) { { rescue_handlers: { NotImplementedError => -> { Rack::Response.new('rescued', 200, {}) } } } }
-
-      it 'rescues the exception using the provided handler' do
-        get '/'
-        expect(last_response.body).to eq('rescued')
-      end
-    end
-  end
-
-  context do
-    let(:running_app) { exception_app }
-    let(:options) { { rescue_all: true, default_status: 500 } }
-
-    it 'is possible to specify a different default status code' do
-      get '/'
-      expect(last_response.status).to eq(500)
-    end
-  end
-
-  context do
-    let(:running_app) { exception_app }
-    let(:options) { { rescue_all: true, format: :json } }
-
-    it 'is possible to return errors in json format' do
-      get '/'
-      expect(last_response.body).to eq('{"error":"rain!"}')
-    end
-  end
-
-  context do
-    let(:running_app) { error_hash_app }
-    let(:options) { { rescue_all: true, format: :json } }
-
-    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
-
-  context do
-    let(:running_app) { exception_app }
-    let(:options) { { rescue_all: true, format: :jsonapi } }
-
-    it 'is possible to return errors in jsonapi format' do
-      get '/'
-      expect(last_response.body).to eq('{&quot;error&quot;:&quot;rain!&quot;}')
-    end
-  end
-
-  context do
-    let(:running_app) { error_hash_app }
-    let(:options) { { rescue_all: true, format: :jsonapi } }
-
-    it 'is possible to return hash errors in jsonapi format' do
-      get '/'
-      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
-
-  context do
-    let(:running_app) { exception_app }
-    let(:options) { { rescue_all: true, format: :xml } }
-
-    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
-
-  context do
-    let(:running_app) { error_hash_app }
-    let(:options) { { rescue_all: true, format: :xml } }
-
-    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
-
-  context do
-    let(:running_app) { exception_app }
-    let(:options) do
-      {
-        rescue_all: true,
-        format: :custom,
-        error_formatters: {
-          custom: lambda do |message, _backtrace, _options, _env, _original_exception|
-            { custom_formatter: message }.inspect
-          end
-        }
-      }
-    end
-
-    it 'is possible to specify a custom formatter' do
-      get '/'
-      expect(last_response.body).to eq('{:custom_formatter=&gt;&quot;rain!&quot;}')
-    end
-  end
-
-  context do
-    let(:running_app) { access_denied_app }
-    let(:options) { {} }
-
-    it 'does not trap regular error! codes' do
-      get '/'
-      expect(last_response.status).to eq(401)
-    end
-  end
-
-  context do
-    let(:running_app) { custom_error_app }
-    let(:options) { { rescue_all: false } }
-
-    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
-    let(:running_app) { exception_app }
-    let(:options) do
-      {
-        rescue_all: true,
-        format: :json,
-        rescue_options: { backtrace: true, original_exception: true }
-      }
-    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
-    let(:running_app) { exception_app }
-    let(:options) do
-      {
-        rescue_all: true,
-        format: :xml,
-        rescue_options: { backtrace: true, original_exception: true }
-      }
-    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
-    let(:running_app) { exception_app }
-    let(:options) do
-      {
-        rescue_all: true,
-        format: :txt,
-        rescue_options: { backtrace: true, original_exception: true }
-      }
-    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