grape 1.7.0 → 1.8.0

data/spec/grape/exceptions/body_parse_errors_spec.rb

@@ -91,6 +91,46 @@ describe Grape::Exceptions::ValidationErrors do
     end
   end
 
+  context 'api with rescue_from :grape_exceptions handler with block' do
+    subject { Class.new(Grape::API) }
+
+    before do
+      subject.rescue_from :grape_exceptions do |e|
+        rack_response "Custom Error Contents, Original Message: #{e.message}", 400
+      end
+
+      subject.params do
+        requires :beer
+      end
+
+      subject.post '/beer' do
+        'beer received'
+      end
+    end
+
+    def app
+      subject
+    end
+
+    context 'with content_type json' do
+      it 'returns body parsing error message' do
+        post '/beer', 'test', 'CONTENT_TYPE' => 'application/json'
+        expect(last_response.status).to eq 400
+        expect(last_response.body).to include 'message body does not match declared format'
+        expect(last_response.body).to include 'Custom Error Contents, Original Message'
+      end
+    end
+
+    context 'with content_type xml' do
+      it 'returns body parsing error message' do
+        post '/beer', 'test', 'CONTENT_TYPE' => 'application/xml'
+        expect(last_response.status).to eq 400
+        expect(last_response.body).to include 'message body does not match declared format'
+        expect(last_response.body).to include 'Custom Error Contents, Original Message'
+      end
+    end
+  end
+
   context 'api without a rescue handler' do
     subject { Class.new(Grape::API) }
 

data/spec/grape/exceptions/invalid_accept_header_spec.rb

@@ -10,11 +10,13 @@ describe Grape::Exceptions::InvalidAcceptHeader do
       expect(last_response.body).to eq('beer received')
     end
   end
+
   shared_examples_for 'a cascaded request' do
     it 'does not find a matching route' do
       expect(last_response.status).to eq 404
     end
   end
+
   shared_examples_for 'a not-cascaded request' do
     it 'does not include the X-Cascade=pass header' do
       expect(last_response.headers['X-Cascade']).to be_nil
@@ -24,6 +26,7 @@ describe Grape::Exceptions::InvalidAcceptHeader do
       expect(last_response.status).to eq 406
     end
   end
+
   shared_examples_for 'a rescued request' do
     it 'does not include the X-Cascade=pass header' do
       expect(last_response.headers['X-Cascade']).to be_nil

data/spec/grape/exceptions/missing_group_type_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'shared/deprecated_class_examples'
+
 RSpec.describe Grape::Exceptions::MissingGroupType do
   describe '#message' do
     subject { described_class.new.message }
@@ -7,15 +9,9 @@ RSpec.describe Grape::Exceptions::MissingGroupType do
     it { is_expected.to include 'group type is required' }
   end
 
-  describe 'deprecated Grape::Exceptions::MissingGroupTypeError' do
-    subject { Grape::Exceptions::MissingGroupTypeError.new }
-
-    it 'puts a deprecation warning' do
-      expect(Warning).to receive(:warn) do |message|
-        expect(message).to include('`Grape::Exceptions::MissingGroupTypeError` is deprecated')
-      end
+  describe 'Grape::Exceptions::MissingGroupTypeError' do
+    let(:deprecated_class) { Grape::Exceptions::MissingGroupTypeError }
 
-      subject
-    end
+    it_behaves_like 'deprecated class'
   end
 end

data/spec/grape/exceptions/unsupported_group_type_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'shared/deprecated_class_examples'
+
 RSpec.describe Grape::Exceptions::UnsupportedGroupType do
   subject { described_class.new }
 
@@ -9,15 +11,9 @@ RSpec.describe Grape::Exceptions::UnsupportedGroupType do
     it { is_expected.to include 'group type must be Array, Hash, JSON or Array[JSON]' }
   end
 
-  describe 'deprecated Grape::Exceptions::UnsupportedGroupTypeError' do
-    subject { Grape::Exceptions::UnsupportedGroupTypeError.new }
-
-    it 'puts a deprecation warning' do
-      expect(Warning).to receive(:warn) do |message|
-        expect(message).to include('`Grape::Exceptions::UnsupportedGroupTypeError` is deprecated')
-      end
+  describe 'Grape::Exceptions::UnsupportedGroupTypeError' do
+    let(:deprecated_class) { Grape::Exceptions::UnsupportedGroupTypeError }
 
-      subject
-    end
+    it_behaves_like 'deprecated class'
   end
 end

data/spec/grape/grape_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RSpec.describe Grape do
+  describe '.config' do
+    subject { described_class.config }
+
+    it { is_expected.to eq(param_builder: Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder) }
+  end
+end

data/spec/grape/integration/rack_spec.rb

@@ -27,19 +27,20 @@ describe Rack do
   end
 
   context 'when the app is mounted' do
-    def app
-      @main_app ||= Class.new(Grape::API) do
+    let(:ping_mount) do
+      Class.new(Grape::API) do
         get 'ping'
       end
     end
 
-    let!(:base) do
-      app_to_mount = app
-      Class.new(Grape::API) do
+    let(:app) do
+      app_to_mount = ping_mount
+      app = Class.new(Grape::API) do
         namespace 'namespace' do
           mount app_to_mount
         end
       end
+      Rack::Builder.new(app)
     end
 
     it 'finds the app on the namespace' do

data/spec/grape/middleware/base_spec.rb

@@ -70,18 +70,18 @@ describe Grape::Middleware::Base do
 
   it 'is able to access the response' do
     subject.call({})
-    expect(subject.response).to be_kind_of(Rack::Response)
+    expect(subject.response).to be_a(Rack::Response)
   end
 
   describe '#response' do
     subject do
-      puts described_class
       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
@@ -97,12 +97,14 @@ describe Grape::Middleware::Base do
       end
 
       it 'returns the memoized Rack::Response instance' do
-        expect(subject.response).to be(subject.response)
+        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(:response) { ->(_) { Rack::Response.new('test', 204, abc: 1) } }
+      let(:rack_response) { Rack::Response.new('test', 204, abc: 1) }
+      let(:response) { ->(_) { rack_response } }
 
       it 'status' do
         expect(subject.response.status).to eq(204)
@@ -117,7 +119,7 @@ describe Grape::Middleware::Base do
       end
 
       it 'returns the memoized Rack::Response instance' do
-        expect(subject.response).to be(subject.response)
+        expect(subject.response).to eq(rack_response)
       end
     end
   end

data/spec/grape/middleware/formatter_spec.rb

@@ -13,7 +13,7 @@ describe Grape::Middleware::Formatter do
 
     it 'looks at the bodies for possibly serializable data' do
       _, _, bodies = *subject.call('PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json')
-      bodies.each { |b| expect(b).to eq(::Grape::Json.dump(body)) }
+      bodies.each { |b| expect(b).to eq(::Grape::Json.dump(body)) } # rubocop:disable RSpec/IteratedExpectation
     end
 
     context 'default format' do
@@ -26,7 +26,7 @@ describe Grape::Middleware::Formatter do
           end
         end
 
-        subject.call('PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json').to_a.last.each { |b| expect(b).to eq('"bar"') }
+        subject.call('PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json').to_a.last.each { |b| expect(b).to eq('"bar"') } # rubocop:disable RSpec/IteratedExpectation
       end
     end
 
@@ -40,7 +40,7 @@ describe Grape::Middleware::Formatter do
           end
         end
 
-        subject.call('PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/vnd.api+json').to_a.last.each { |b| expect(b).to eq('{"foos":[{"bar":"baz"}] }') }
+        subject.call('PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/vnd.api+json').to_a.last.each { |b| expect(b).to eq('{"foos":[{"bar":"baz"}] }') } # rubocop:disable RSpec/IteratedExpectation
       end
     end
 
@@ -53,8 +53,7 @@ describe Grape::Middleware::Formatter do
             '<bar/>'
           end
         end
-
-        subject.call('PATH_INFO' => '/somewhere.xml', 'HTTP_ACCEPT' => 'application/json').to_a.last.each { |b| expect(b).to eq('<bar/>') }
+        subject.call('PATH_INFO' => '/somewhere.xml', 'HTTP_ACCEPT' => 'application/json').to_a.last.each { |b| expect(b).to eq('<bar/>') } # rubocop:disable RSpec/IteratedExpectation
       end
     end
   end
@@ -243,6 +242,7 @@ describe Grape::Middleware::Formatter do
   end
 
   context 'input' do
+    content_types = ['application/json', 'application/json; charset=utf-8'].freeze
     %w[POST PATCH PUT DELETE].each do |method|
       context 'when body is not nil or empty' do
         context 'when Content-Type is supported' do
@@ -320,7 +320,7 @@ describe Grape::Middleware::Formatter do
         end
       end
 
-      ['application/json', 'application/json; charset=utf-8'].each do |content_type|
+      content_types.each do |content_type|
         context content_type do
           it "parses the body from #{method} and copies values into rack.request.form_hash" do
             io = StringIO.new('{"is_boolean":true,"string":"thing"}')
@@ -405,7 +405,7 @@ describe Grape::Middleware::Formatter do
       env = { 'PATH_INFO' => '/somewhere', 'HTTP_ACCEPT' => 'application/json' }
       status, headers, body = subject.call(env)
       expect(status).to be == 200
-      expect(headers).to be == { 'Content-Type' => 'application/json' }
+      expect(headers.transform_keys(&:downcase)).to be == { 'content-type' => 'application/json' }
       expect(read_chunks(body)).to be == ['data']
     end
   end

data/spec/grape/request_spec.rb

@@ -62,29 +62,19 @@ module Grape
       end
     end
 
-    describe 'when the param_builder is set to Hashie' do
+    describe 'when the build_params_with is set to Hashie' do
       subject(:request_params) { described_class.new(env, **opts).params }
 
-      before do
-        Grape.configure do |config|
-          config.param_builder = Grape::Extensions::Hashie::Mash::ParamBuilder
-        end
-      end
-
-      after do
-        Grape.config.reset
-      end
-
       context 'when the API does not include a specific param builder' do
         let(:opts) { {} }
 
-        it { is_expected.to be_a(Hashie::Mash) }
+        it { is_expected.to be_a(Hash) }
       end
 
       context 'when the API includes a specific param builder' do
-        let(:opts) { { build_params_with: Grape::Extensions::Hash::ParamBuilder } }
+        let(:opts) { { build_params_with: Grape::Extensions::Hashie::Mash::ParamBuilder } }
 
-        it { is_expected.to be_a(Hash) }
+        it { is_expected.to be_a(Hashie::Mash) }
       end
     end
 

data/spec/grape/validations/multiple_attributes_iterator_spec.rb

@@ -12,8 +12,8 @@ describe Grape::Validations::MultipleAttributesIterator do
         { first: 'string', second: 'string' }
       end
 
-      it 'yields the whole params hash and the skipped flag without the list of attrs' do
-        expect { |b| iterator.each(&b) }.to yield_with_args(params, false)
+      it 'yields the whole params hash without the list of attrs' do
+        expect { |b| iterator.each(&b) }.to yield_with_args(params)
       end
     end
 
@@ -23,17 +23,15 @@ describe Grape::Validations::MultipleAttributesIterator do
       end
 
       it 'yields each element of the array without the list of attrs' do
-        expect { |b| iterator.each(&b) }.to yield_successive_args([params[0], false], [params[1], false])
+        expect { |b| iterator.each(&b) }.to yield_successive_args(params[0], params[1])
       end
     end
 
     context 'when params is empty optional placeholder' do
-      let(:params) do
-        [Grape::DSL::Parameters::EmptyOptionalValue, { first: 'string2', second: 'string2' }]
-      end
+      let(:params) { [Grape::DSL::Parameters::EmptyOptionalValue] }
 
-      it 'yields each element of the array without the list of attrs' do
-        expect { |b| iterator.each(&b) }.to yield_successive_args([Grape::DSL::Parameters::EmptyOptionalValue, true], [params[1], false])
+      it 'does not yield it' do
+        expect { |b| iterator.each(&b) }.to yield_successive_args
       end
     end
   end

data/spec/grape/validations/single_attribute_iterator_spec.rb

@@ -14,7 +14,7 @@ describe Grape::Validations::SingleAttributeIterator do
 
       it 'yields params and every single attribute from the list' do
         expect { |b| iterator.each(&b) }
-          .to yield_successive_args([params, :first, false, false], [params, :second, false, false])
+          .to yield_successive_args([params, :first, false], [params, :second, false])
       end
     end
 
@@ -25,8 +25,8 @@ describe Grape::Validations::SingleAttributeIterator do
 
       it 'yields every single attribute from the list for each of the array elements' do
         expect { |b| iterator.each(&b) }.to yield_successive_args(
-          [params[0], :first, false, false], [params[0], :second, false, false],
-          [params[1], :first, false, false], [params[1], :second, false, false]
+          [params[0], :first, false], [params[0], :second, false],
+          [params[1], :first, false], [params[1], :second, false]
         )
       end
 
@@ -35,9 +35,9 @@ describe Grape::Validations::SingleAttributeIterator do
 
         it 'marks params with empty values' do
           expect { |b| iterator.each(&b) }.to yield_successive_args(
-            [params[0], :first, true, false], [params[0], :second, true, false],
-            [params[1], :first, true, false], [params[1], :second, true, false],
-            [params[2], :first, false, false], [params[2], :second, false, false]
+            [params[0], :first, true], [params[0], :second, true],
+            [params[1], :first, true], [params[1], :second, true],
+            [params[2], :first, false], [params[2], :second, false]
           )
         end
       end
@@ -45,10 +45,9 @@ describe Grape::Validations::SingleAttributeIterator do
       context 'when missing optional value' do
         let(:params) { [Grape::DSL::Parameters::EmptyOptionalValue, 10] }
 
-        it 'marks params with skipped values' do
+        it 'does not yield skipped values' do
           expect { |b| iterator.each(&b) }.to yield_successive_args(
-            [params[0], :first, false, true], [params[0], :second, false, true],
-            [params[1], :first, false, false], [params[1], :second, false, false]
+            [params[1], :first, false], [params[1], :second, false]
           )
         end
       end

data/spec/grape/validations/validators/base_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+RSpec.describe Grape::Validations::Validators::Base do
+  describe '#inherited' do
+    context 'when validator is anonymous' do
+      subject(:custom_validator) { Class.new(described_class) }
+
+      it 'does not register the validator' do
+        expect(Grape::Validations).not_to receive(:register_validator)
+        custom_validator
+      end
+    end
+
+    # Anonymous class does not have a name and class A < B would leak.
+    # Simulates inherited callback
+    context "when validator's underscored name does not end with _validator" do
+      subject(:custom_validator) { described_class.inherited(TestModule::CustomValidatorABC) }
+
+      before { stub_const('TestModule::CustomValidatorABC', Class.new) }
+
+      it 'registers the custom validator with a short name' do
+        expect(Grape::Validations).to receive(:register_validator).with('custom_validator_abc', TestModule::CustomValidatorABC)
+        custom_validator
+      end
+    end
+
+    context "when validator's underscored name ends with _validator" do
+      subject(:custom_validator) { described_class.inherited(TestModule::CustomValidator) }
+
+      before { stub_const('TestModule::CustomValidator', Class.new) }
+
+      it 'registers the custom validator with short name not ending with validator' do
+        expect(Grape::Validations).to receive(:register_validator).with('custom', TestModule::CustomValidator)
+        custom_validator
+      end
+    end
+  end
+end

data/spec/grape/validations/validators/values_spec.rb

@@ -30,6 +30,10 @@ describe Grape::Validations::Validators::ValuesValidator do
         def include?(value)
           values.include?(value)
         end
+
+        def even?(value)
+          value.to_i.even?
+        end
       end
     end
   end
@@ -114,6 +118,13 @@ describe Grape::Validations::Validators::ValuesValidator do
         { type: params[:type] }
       end
 
+      params do
+        optional :type, type: Integer, values: 1..
+      end
+      get '/endless' do
+        { type: params[:type] }
+      end
+
       params do
         requires :type, values: ->(v) { ValuesModel.include? v }
       end
@@ -234,6 +245,18 @@ describe Grape::Validations::Validators::ValuesValidator do
       end
       get '/proc/message'
 
+      params do
+        requires :number, values: { value: ->(v) { ValuesModel.even? v }, message: 'must be even' }
+      end
+      get '/proc/custom_message' do
+        { message: 'success' }
+      end
+
+      params do
+        requires :input_one, :input_two, values: { value: ->(v1, v2) { v1 + v2 > 10 } }
+      end
+      get '/proc/arity2'
+
       params do
         optional :name, type: String, values: %w[a b], allow_blank: true
       end
@@ -374,6 +397,18 @@ describe Grape::Validations::Validators::ValuesValidator do
     expect(last_response.body).to eq({ error: 'type does not have a valid value' }.to_json)
   end
 
+  it 'validates against values in an endless range', if: ActiveSupport::VERSION::MAJOR >= 6 do
+    get('/endless', type: 10)
+    expect(last_response.status).to eq 200
+    expect(last_response.body).to eq({ type: 10 }.to_json)
+  end
+
+  it 'does not allow an invalid value for a parameter using an endless range', if: ActiveSupport::VERSION::MAJOR >= 6 do
+    get('/endless', type: 0)
+    expect(last_response.status).to eq 400
+    expect(last_response.body).to eq({ error: 'type does not have a valid value' }.to_json)
+  end
+
   it 'does not allow non-numeric string value for int value using lambda' do
     get('/lambda_int_val', number: 'foo')
     expect(last_response.status).to eq 400
@@ -673,5 +708,26 @@ describe Grape::Validations::Validators::ValuesValidator do
       expect(last_response.status).to eq 400
       expect(last_response.body).to eq({ error: 'type failed check' }.to_json)
     end
+
+    context 'when proc has an arity of 1' do
+      it 'accepts a valid value' do
+        get '/proc/custom_message', number: 4
+        expect(last_response.status).to eq 200
+        expect(last_response.body).to eq({ message: 'success' }.to_json)
+      end
+
+      it 'rejects an invalid value' do
+        get '/proc/custom_message', number: 5
+        expect(last_response.status).to eq 400
+        expect(last_response.body).to eq({ error: 'number must be even' }.to_json)
+      end
+    end
+
+    context 'when arity is > 1' do
+      it 'returns an error status code' do
+        get '/proc/arity2', input_one: 2, input_two: 3
+        expect(last_response.status).to eq 400
+      end
+    end
   end
 end

data/spec/grape/validations_spec.rb

@@ -179,11 +179,12 @@ describe Grape::Validations do
     context 'requires :all using Grape::Entity documentation' do
       def define_requires_all
         documentation = {
-          required_field: { type: String },
-          optional_field: { type: String }
+          required_field: { type: String, required: true, param_type: 'query' },
+          optional_field: { type: String },
+          optional_array_field: { type: Array[String], is_array: true }
         }
         subject.params do
-          requires :all, except: :optional_field, using: documentation
+          requires :all, except: %i[optional_field optional_array_field], using: documentation
         end
       end
       before do
@@ -195,7 +196,7 @@ describe Grape::Validations do
 
       it 'adds entity documentation to declared params' do
         define_requires_all
-        expect(Grape::Validations::ParamsScope::Attr.attrs_keys(declared_params)).to eq(%i[required_field optional_field])
+        expect(Grape::Validations::ParamsScope::Attr.attrs_keys(declared_params)).to eq(%i[required_field optional_field optional_array_field])
       end
 
       it 'errors when required_field is not present' do
@@ -214,8 +215,8 @@ describe Grape::Validations do
     context 'requires :none using Grape::Entity documentation' do
       def define_requires_none
         documentation = {
-          required_field: { type: String },
-          optional_field: { type: String }
+          required_field: { type: String, example: 'Foo' },
+          optional_field: { type: Integer, format: 'int64' }
         }
         subject.params do
           requires :none, except: :required_field, using: documentation
@@ -1071,12 +1072,12 @@ describe Grape::Validations do
             }
             # debugger
             get '/multi_level', data
-            expect(last_response.body.split(', ')).to match_array([
-                                                                    'top[3][top_id] is empty',
-                                                                    'top[2][middle_1][0][middle_1_id] is empty',
-                                                                    'top[1][middle_1][1][middle_2][0][middle_2_id] is empty',
-                                                                    'top[0][middle_1][1][middle_2][1][bottom][0][bottom_id] is empty'
-                                                                  ])
+            expect(last_response.body.split(', ')).to contain_exactly(
+              'top[3][top_id] is empty',
+              'top[2][middle_1][0][middle_1_id] is empty',
+              'top[1][middle_1][1][middle_2][0][middle_2_id] is empty',
+              'top[0][middle_1][1][middle_2][1][bottom][0][bottom_id] is empty'
+            )
             expect(last_response.status).to eq(400)
           end
         end
@@ -1509,6 +1510,29 @@ describe Grape::Validations do
       end
     end
 
+    context 'with block and empty args' do
+      before do
+        subject.helpers do
+          params :shared_params do |empty_args|
+            optional :param, default: empty_args[:some]
+          end
+        end
+        subject.format :json
+        subject.params do
+          use :shared_params
+        end
+        subject.get '/shared_params' do
+          :ok
+        end
+      end
+
+      it 'works' do
+        get '/shared_params'
+
+        expect(last_response.status).to eq(200)
+      end
+    end
+
     context 'all or none' do
       context 'optional params' do
         before do

data/spec/shared/deprecated_class_examples.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'deprecated class' do
+  subject { deprecated_class.new }
+
+  around do |example|
+    old_deprec_behavior = ActiveSupport::Deprecation.behavior
+    ActiveSupport::Deprecation.behavior = :raise
+    example.run
+    ActiveSupport::Deprecation.behavior = old_deprec_behavior
+  end
+
+  it 'raises an ActiveSupport::DeprecationException' do
+    expect { subject }.to raise_error(ActiveSupport::DeprecationException)
+  end
+end