grape 1.1.0 → 1.5.3

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

@@ -1,66 +1,212 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::AtLeastOneOfValidator do
   describe '#validate!' do
-    let(:scope) do
-      Struct.new(:opts) do
-        def params(arg)
-          arg
-        end
+    subject(:validate) { post path, params }
+
+    module ValidationsSpec
+      module AtLeastOneOfValidatorSpec
+        class API < Grape::API
+          rescue_from Grape::Exceptions::ValidationErrors do |e|
+            error!(e.errors.transform_keys! { |key| key.join(',') }, 400)
+          end
+
+          params do
+            optional :beer, :wine, :grapefruit
+            at_least_one_of :beer, :wine, :grapefruit
+          end
+          post do
+          end
+
+          params do
+            optional :beer, :wine, :grapefruit, :other
+            at_least_one_of :beer, :wine, :grapefruit
+          end
+          post 'mixed-params' do
+          end
+
+          params do
+            optional :beer, :wine, :grapefruit
+            at_least_one_of :beer, :wine, :grapefruit, message: 'you should choose something'
+          end
+          post '/custom-message' do
+          end
 
-        def required?; end
+          params do
+            requires :item, type: Hash do
+              optional :beer, :wine, :grapefruit
+              at_least_one_of :beer, :wine, :grapefruit, message: 'fail'
+            end
+          end
+          post '/nested-hash' do
+          end
+
+          params do
+            requires :items, type: Array do
+              optional :beer, :wine, :grapefruit
+              at_least_one_of :beer, :wine, :grapefruit, message: 'fail'
+            end
+          end
+          post '/nested-array' do
+          end
+
+          params do
+            requires :items, type: Array do
+              requires :nested_items, type: Array do
+                optional :beer, :wine, :grapefruit
+                at_least_one_of :beer, :wine, :grapefruit, message: 'fail'
+              end
+            end
+          end
+          post '/deeply-nested-array' do
+          end
+        end
       end
     end
-    let(:at_least_one_of_params) { %i[beer wine grapefruit] }
-    let(:validator) { described_class.new(at_least_one_of_params, {}, false, scope.new) }
+
+    def app
+      ValidationsSpec::AtLeastOneOfValidatorSpec::API
+    end
 
     context 'when all restricted params are present' do
+      let(:path) { '/' }
       let(:params) { { beer: true, wine: true, grapefruit: true } }
 
-      it 'does not raise a validation exception' do
-        expect(validator.validate!(params)).to eql params
+      it 'does not return a validation error' do
+        validate
+        expect(last_response.status).to eq 201
       end
 
       context 'mixed with other params' do
-        let(:mixed_params) { params.merge!(other: true, andanother: true) }
+        let(:path) { '/mixed-params' }
+        let(:params) { { beer: true, wine: true, grapefruit: true, other: true } }
 
-        it 'does not raise a validation exception' do
-          expect(validator.validate!(mixed_params)).to eql mixed_params
+        it 'does not return a validation error' do
+          validate
+          expect(last_response.status).to eq 201
         end
       end
     end
 
     context 'when a subset of restricted params are present' do
+      let(:path) { '/' }
       let(:params) { { beer: true, grapefruit: true } }
 
-      it 'does not raise a validation exception' do
-        expect(validator.validate!(params)).to eql params
+      it 'does not return a validation error' do
+        validate
+        expect(last_response.status).to eq 201
       end
     end
 
-    context 'when params keys come as strings' do
-      let(:params) { { 'beer' => true, 'grapefruit' => true } }
+    context 'when none of the restricted params is selected' do
+      let(:path) { '/' }
+      let(:params) { { other: true } }
 
-      it 'does not raise a validation exception' do
-        expect(validator.validate!(params)).to eql params
+      it 'returns a validation error' do
+        validate
+        expect(last_response.status).to eq 400
+        expect(JSON.parse(last_response.body)).to eq(
+          'beer,wine,grapefruit' => ['are missing, at least one parameter must be provided']
+        )
       end
-    end
 
-    context 'when none of the restricted params is selected' do
-      let(:params) { { somethingelse: true } }
+      context 'when custom message is specified' do
+        let(:path) { '/custom-message' }
 
-      it 'raises a validation exception' do
-        expect do
-          validator.validate! params
-        end.to raise_error(Grape::Exceptions::Validation)
+        it 'returns a validation error' do
+          validate
+          expect(last_response.status).to eq 400
+          expect(JSON.parse(last_response.body)).to eq(
+            'beer,wine,grapefruit' => ['you should choose something']
+          )
+        end
       end
     end
 
     context 'when exactly one of the restricted params is selected' do
-      let(:params) { { beer: true, somethingelse: true } }
+      let(:path) { '/' }
+      let(:params) { { beer: true } }
+
+      it 'does not return a validation error' do
+        validate
+        expect(last_response.status).to eq 201
+      end
+    end
+
+    context 'when restricted params are nested inside hash' do
+      let(:path) { '/nested-hash' }
+
+      context 'when at least one of them is present' do
+        let(:params) { { item: { beer: true, wine: true } } }
+
+        it 'does not return a validation error' do
+          validate
+          expect(last_response.status).to eq 201
+        end
+      end
 
-      it 'does not raise a validation exception' do
-        expect(validator.validate!(params)).to eql params
+      context 'when none of them are present' do
+        let(:params) { { item: { other: true } } }
+
+        it 'returns a validation error with full names of the params' do
+          validate
+          expect(last_response.status).to eq 400
+          expect(JSON.parse(last_response.body)).to eq(
+            'item[beer],item[wine],item[grapefruit]' => ['fail']
+          )
+        end
+      end
+    end
+
+    context 'when restricted params are nested inside array' do
+      let(:path) { '/nested-array' }
+
+      context 'when at least one of them is present' do
+        let(:params) { { items: [{ beer: true, wine: true }, { grapefruit: true }] } }
+
+        it 'does not return a validation error' do
+          validate
+          expect(last_response.status).to eq 201
+        end
+      end
+
+      context 'when none of them are present' do
+        let(:params) { { items: [{ beer: true, other: true }, { other: true }] } }
+
+        it 'returns a validation error with full names of the params' do
+          validate
+          expect(last_response.status).to eq 400
+          expect(JSON.parse(last_response.body)).to eq(
+            'items[1][beer],items[1][wine],items[1][grapefruit]' => ['fail']
+          )
+        end
+      end
+    end
+
+    context 'when restricted params are deeply nested' do
+      let(:path) { '/deeply-nested-array' }
+
+      context 'when at least one of them is present' do
+        let(:params) { { items: [{ nested_items: [{ wine: true }] }] } }
+
+        it 'does not return a validation error' do
+          validate
+          expect(last_response.status).to eq 201
+        end
+      end
+
+      context 'when none of them are present' do
+        let(:params) { { items: [{ nested_items: [{ other: true }] }] } }
+
+        it 'returns a validation error with full names of the params' do
+          validate
+          expect(last_response.status).to eq 400
+          expect(JSON.parse(last_response.body)).to eq(
+            'items[0][nested_items][0][beer],items[0][nested_items][0][wine],items[0][nested_items][0][grapefruit]' => ['fail']
+          )
+        end
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::CoerceValidator do
@@ -10,20 +12,25 @@ describe Grape::Validations::CoerceValidator do
   end
 
   describe 'coerce' do
-    module CoerceValidatorSpec
-      class User
-        include Virtus.model
-        attribute :id, Integer
-        attribute :name, String
+    class SecureURIOnly
+      def self.parse(value)
+        URI.parse(value)
+      end
+
+      def self.parsed?(value)
+        value.is_a? URI::HTTPS
       end
     end
 
     context 'i18n' do
       after :each do
+        I18n.available_locales = %i[en]
         I18n.locale = :en
+        I18n.default_locale = :en
       end
 
       it 'i18n error on malformed input' do
+        I18n.available_locales = %i[en zh-CN]
         I18n.load_path << File.expand_path('../zh-CN.yml', __FILE__)
         I18n.reload!
         I18n.locale = 'zh-CN'.to_sym
@@ -40,6 +47,7 @@ describe Grape::Validations::CoerceValidator do
       end
 
       it 'gives an english fallback error when default locale message is blank' do
+        I18n.available_locales = %i[en pt-BR]
         I18n.locale = 'pt-BR'.to_sym
         subject.params do
           requires :age, type: Integer
@@ -92,6 +100,7 @@ describe Grape::Validations::CoerceValidator do
 
         it 'respects :coerce_with' do
           get '/', a: 'yup'
+
           expect(last_response.status).to eq(200)
           expect(last_response.body).to eq('TrueClass')
         end
@@ -144,26 +153,50 @@ describe Grape::Validations::CoerceValidator do
       expect(last_response.body).to eq('array int works')
     end
 
-    context 'complex objects' do
-      it 'error on malformed input for complex objects' do
-        subject.params do
-          requires :user, type: CoerceValidatorSpec::User
+    context 'coerces' do
+      context 'json' do
+        let(:headers) { { 'CONTENT_TYPE' => 'application/json', 'ACCEPT' => 'application/json' } }
+
+        it 'BigDecimal' do
+          subject.params do
+            requires :bigdecimal, type: BigDecimal
+          end
+          subject.post '/bigdecimal' do
+            "#{params[:bigdecimal].class} #{params[:bigdecimal].to_f}"
+          end
+
+          post '/bigdecimal', { bigdecimal: 45.1 }.to_json, headers
+          expect(last_response.status).to eq(201)
+          expect(last_response.body).to eq('BigDecimal 45.1')
         end
-        subject.get '/user' do
-          'complex works'
+
+        it 'Boolean' do
+          subject.params do
+            requires :boolean, type: Boolean
+          end
+          subject.post '/boolean' do
+            params[:boolean]
+          end
+
+          post '/boolean', { boolean: 'true' }.to_json, headers
+          expect(last_response.status).to eq(201)
+          expect(last_response.body).to eq('true')
         end
+      end
 
-        get '/user', user: '32'
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('user is invalid')
+      it 'BigDecimal' do
+        subject.params do
+          requires :bigdecimal, coerce: BigDecimal
+        end
+        subject.get '/bigdecimal' do
+          params[:bigdecimal].class
+        end
 
-        get '/user', user: { id: 32, name: 'Bob' }
+        get '/bigdecimal', bigdecimal: '45'
         expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('complex works')
+        expect(last_response.body).to eq('BigDecimal')
       end
-    end
 
-    context 'coerces' do
       it 'Integer' do
         subject.params do
           requires :int, coerce: Integer
@@ -177,6 +210,70 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.body).to eq(integer_class_name)
       end
 
+      it 'String' do
+        subject.params do
+          requires :string, coerce: String
+        end
+        subject.get '/string' do
+          params[:string].class
+        end
+
+        get '/string', string: 45
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('String')
+
+        get '/string', string: nil
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('NilClass')
+      end
+
+      context 'a custom type' do
+        it 'coerces the given value' do
+          subject.params do
+            requires :uri, coerce: SecureURIOnly
+          end
+          subject.get '/secure_uri' do
+            params[:uri].class
+          end
+
+          get 'secure_uri', uri: 'https://www.example.com'
+
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('URI::HTTPS')
+
+          get 'secure_uri', uri: 'http://www.example.com'
+
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('uri is invalid')
+        end
+
+        context 'returning the InvalidValue instance when invalid' do
+          let(:custom_type) do
+            Class.new do
+              def self.parse(_val)
+                Grape::Types::InvalidValue.new('must be unique')
+              end
+            end
+          end
+
+          it 'uses a custom message added to the invalid value' do
+            type = custom_type
+
+            subject.params do
+              requires :name, type: type
+            end
+            subject.get '/whatever' do
+              params[:name].class
+            end
+
+            get 'whatever', name: 'Bob'
+
+            expect(last_response.status).to eq(400)
+            expect(last_response.body).to eq('name must be unique')
+          end
+        end
+      end
+
       context 'Array' do
         it 'Array of Integers' do
           subject.params do
@@ -193,7 +290,7 @@ describe Grape::Validations::CoerceValidator do
 
         it 'Array of Bools' do
           subject.params do
-            requires :arry, coerce: Array[Virtus::Attribute::Boolean]
+            requires :arry, coerce: Array[Grape::API::Boolean]
           end
           subject.get '/array' do
             params[:arry][0].class
@@ -204,27 +301,6 @@ describe Grape::Validations::CoerceValidator do
           expect(last_response.body).to eq('TrueClass')
         end
 
-        it 'Array of Complex' do
-          subject.params do
-            requires :arry, coerce: Array[CoerceValidatorSpec::User]
-          end
-          subject.get '/array' do
-            params[:arry].size
-          end
-
-          get 'array', arry: [31]
-          expect(last_response.status).to eq(400)
-          expect(last_response.body).to eq('arry is invalid')
-
-          get 'array', arry: { id: 31, name: 'Alice' }
-          expect(last_response.status).to eq(400)
-          expect(last_response.body).to eq('arry is invalid')
-
-          get 'array', arry: [{ id: 31, name: 'Alice' }]
-          expect(last_response.status).to eq(200)
-          expect(last_response.body).to eq('1')
-        end
-
         it 'Array of type implementing parse' do
           subject.params do
             requires :uri, type: Array[URI]
@@ -249,17 +325,7 @@ describe Grape::Validations::CoerceValidator do
           expect(last_response.body).to eq('Set,URI::HTTP,1')
         end
 
-        it 'Array of class implementing parse and parsed?' do
-          class SecureURIOnly
-            def self.parse(value)
-              URI.parse(value)
-            end
-
-            def self.parsed?(value)
-              value.is_a? URI::HTTPS
-            end
-          end
-
+        it 'Array of a custom type' do
           subject.params do
             requires :uri, type: Array[SecureURIOnly]
           end
@@ -291,7 +357,7 @@ describe Grape::Validations::CoerceValidator do
 
         it 'Set of Bools' do
           subject.params do
-            requires :set, coerce: Set[Virtus::Attribute::Boolean]
+            requires :set, coerce: Set[Grape::API::Boolean]
           end
           subject.get '/set' do
             params[:set].first.class
@@ -303,100 +369,73 @@ describe Grape::Validations::CoerceValidator do
         end
       end
 
-      it 'Bool' do
-        subject.params do
-          requires :bool, coerce: Virtus::Attribute::Boolean
-        end
-        subject.get '/bool' do
-          params[:bool].class
-        end
-
-        get '/bool', bool: 1
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('TrueClass')
-
-        get '/bool', bool: 0
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('FalseClass')
-
-        get '/bool', bool: 'false'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('FalseClass')
-
-        get '/bool', bool: 'true'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('TrueClass')
-      end
-
       it 'Boolean' do
         subject.params do
-          optional :boolean, type: Boolean, default: true
+          requires :boolean, type: Boolean
         end
         subject.get '/boolean' do
           params[:boolean].class
         end
 
-        get '/boolean'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('TrueClass')
-
-        get '/boolean', boolean: true
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('TrueClass')
-
-        get '/boolean', boolean: false
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('FalseClass')
-
-        get '/boolean', boolean: 'true'
+        get '/boolean', boolean: 1
         expect(last_response.status).to eq(200)
         expect(last_response.body).to eq('TrueClass')
+      end
 
-        get '/boolean', boolean: 'false'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('FalseClass')
+      context 'File' do
+        let(:file) { Rack::Test::UploadedFile.new(__FILE__) }
+        let(:filename) { File.basename(__FILE__).to_s }
 
-        get '/boolean', boolean: 123
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('boolean is invalid')
+        it 'Rack::Multipart::UploadedFile' do
+          subject.params do
+            requires :file, type: Rack::Multipart::UploadedFile
+          end
+          subject.post '/upload' do
+            params[:file][:filename]
+          end
 
-        get '/boolean', boolean: '123'
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('boolean is invalid')
-      end
+          post '/upload', file: file
+          expect(last_response.status).to eq(201)
+          expect(last_response.body).to eq(filename)
 
-      it 'Rack::Multipart::UploadedFile' do
-        subject.params do
-          requires :file, type: Rack::Multipart::UploadedFile
-        end
-        subject.post '/upload' do
-          params[:file][:filename]
+          post '/upload', file: 'not a file'
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('file is invalid')
         end
 
-        post '/upload', file: Rack::Test::UploadedFile.new(__FILE__)
-        expect(last_response.status).to eq(201)
-        expect(last_response.body).to eq(File.basename(__FILE__).to_s)
+        it 'File' do
+          subject.params do
+            requires :file, coerce: File
+          end
+          subject.post '/upload' do
+            params[:file][:filename]
+          end
 
-        post '/upload', file: 'not a file'
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('file is invalid')
-      end
+          post '/upload', file: file
+          expect(last_response.status).to eq(201)
+          expect(last_response.body).to eq(filename)
 
-      it 'File' do
-        subject.params do
-          requires :file, coerce: File
-        end
-        subject.post '/upload' do
-          params[:file][:filename]
+          post '/upload', file: 'not a file'
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('file is invalid')
+
+          post '/upload', file: { filename: 'fake file', tempfile: '/etc/passwd' }
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('file is invalid')
         end
 
-        post '/upload', file: Rack::Test::UploadedFile.new(__FILE__)
-        expect(last_response.status).to eq(201)
-        expect(last_response.body).to eq(File.basename(__FILE__).to_s)
+        it 'collection' do
+          subject.params do
+            requires :files, type: Array[File]
+          end
+          subject.post '/upload' do
+            params[:files].first[:filename]
+          end
 
-        post '/upload', file: 'not a file'
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('file is invalid')
+          post '/upload', files: [file]
+          expect(last_response.status).to eq(201)
+          expect(last_response.body).to eq(filename)
+        end
       end
 
       it 'Nests integers' do
@@ -413,6 +452,165 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.status).to eq(200)
         expect(last_response.body).to eq(integer_class_name)
       end
+
+      context 'nil values' do
+        context 'primitive types' do
+          Grape::Validations::Types::PRIMITIVES.each do |type|
+            it 'respects the nil value' do
+              subject.params do
+                requires :param, type: type
+              end
+              subject.get '/nil_value' do
+                params[:param].class
+              end
+
+              get '/nil_value', param: nil
+              expect(last_response.status).to eq(200)
+              expect(last_response.body).to eq('NilClass')
+            end
+          end
+        end
+
+        context 'structures types' do
+          Grape::Validations::Types::STRUCTURES.each do |type|
+            it 'respects the nil value' do
+              subject.params do
+                requires :param, type: type
+              end
+              subject.get '/nil_value' do
+                params[:param].class
+              end
+
+              get '/nil_value', param: nil
+              expect(last_response.status).to eq(200)
+              expect(last_response.body).to eq('NilClass')
+            end
+          end
+        end
+
+        context 'special types' do
+          Grape::Validations::Types::SPECIAL.each_key do |type|
+            it 'respects the nil value' do
+              subject.params do
+                requires :param, type: type
+              end
+              subject.get '/nil_value' do
+                params[:param].class
+              end
+
+              get '/nil_value', param: nil
+              expect(last_response.status).to eq(200)
+              expect(last_response.body).to eq('NilClass')
+            end
+          end
+
+          context 'variant-member-type collections' do
+            [
+              Array[Integer, String],
+              [Integer, String, Array[Integer, String]]
+            ].each do |type|
+              it 'respects the nil value' do
+                subject.params do
+                  requires :param, type: type
+                end
+                subject.get '/nil_value' do
+                  params[:param].class
+                end
+
+                get '/nil_value', param: nil
+                expect(last_response.status).to eq(200)
+                expect(last_response.body).to eq('NilClass')
+              end
+            end
+          end
+        end
+      end
+
+      context 'empty string' do
+        context 'primitive types' do
+          (Grape::Validations::Types::PRIMITIVES - [String]).each do |type|
+            it "is coerced to nil for type #{type}" do
+              subject.params do
+                requires :param, type: type
+              end
+              subject.get '/empty_string' do
+                params[:param].class
+              end
+
+              get '/empty_string', param: ''
+              expect(last_response.status).to eq(200)
+              expect(last_response.body).to eq('NilClass')
+            end
+          end
+
+          it 'is not coerced to nil for type String' do
+            subject.params do
+              requires :param, type: String
+            end
+            subject.get '/empty_string' do
+              params[:param].class
+            end
+
+            get '/empty_string', param: ''
+            expect(last_response.status).to eq(200)
+            expect(last_response.body).to eq('String')
+          end
+        end
+
+        context 'structures types' do
+          (Grape::Validations::Types::STRUCTURES - [Hash]).each do |type|
+            it "is coerced to nil for type #{type}" do
+              subject.params do
+                requires :param, type: type
+              end
+              subject.get '/empty_string' do
+                params[:param].class
+              end
+
+              get '/empty_string', param: ''
+              expect(last_response.status).to eq(200)
+              expect(last_response.body).to eq('NilClass')
+            end
+          end
+        end
+
+        context 'special types' do
+          (Grape::Validations::Types::SPECIAL.keys - [File, Rack::Multipart::UploadedFile]).each do |type|
+            it "is coerced to nil for type #{type}" do
+              subject.params do
+                requires :param, type: type
+              end
+              subject.get '/empty_string' do
+                params[:param].class
+              end
+
+              get '/empty_string', param: ''
+              expect(last_response.status).to eq(200)
+              expect(last_response.body).to eq('NilClass')
+            end
+          end
+
+          context 'variant-member-type collections' do
+            [
+              Array[Integer, String],
+              [Integer, String, Array[Integer, String]]
+            ].each do |type|
+              it "is coerced to nil for type #{type}" do
+                subject.params do
+                  requires :param, type: type
+                end
+                subject.get '/empty_string' do
+                  params[:param].class
+                end
+
+                get '/empty_string', param: ''
+                expect(last_response.status).to eq(200)
+                expect(last_response.body).to eq('NilClass')
+              end
+            end
+          end
+        end
+      end
     end
 
     context 'using coerce_with' do
@@ -435,19 +633,43 @@ describe Grape::Validations::CoerceValidator do
 
       it 'parses parameters with Array[String] type' do
         subject.params do
-          requires :values, type: Array[String], coerce_with: ->(val) { val.split(/\s+/).map(&:to_i) }
+          requires :values, type: Array[String], coerce_with: ->(val) { val.split(/\s+/) }
         end
-        subject.get '/ints' do
+        subject.get '/strings' do
           params[:values]
         end
 
-        get '/ints', values: '1 2 3 4'
+        get '/strings', values: '1 2 3 4'
         expect(last_response.status).to eq(200)
         expect(JSON.parse(last_response.body)).to eq(%w[1 2 3 4])
 
-        get '/ints', values: 'a b c d'
+        get '/strings', values: 'a b c d'
         expect(last_response.status).to eq(200)
-        expect(JSON.parse(last_response.body)).to eq(%w[0 0 0 0])
+        expect(JSON.parse(last_response.body)).to eq(%w[a b c d])
+      end
+
+      it 'parses parameters with Array[Array[String]] type and coerce_with' do
+        subject.params do
+          requires :values, type: Array[Array[String]], coerce_with: ->(val) { val.is_a?(String) ? [val.split(/,/).map(&:strip)] : val }
+        end
+        subject.post '/coerce_nested_strings' do
+          params[:values]
+        end
+
+        post '/coerce_nested_strings', ::Grape::Json.dump(values: 'a,b,c,d'), 'CONTENT_TYPE' => 'application/json'
+        expect(last_response.status).to eq(201)
+        expect(JSON.parse(last_response.body)).to eq([%w[a b c d]])
+
+        post '/coerce_nested_strings', ::Grape::Json.dump(values: [%w[a c], %w[b]]), 'CONTENT_TYPE' => 'application/json'
+        expect(last_response.status).to eq(201)
+        expect(JSON.parse(last_response.body)).to eq([%w[a c], %w[b]])
+
+        post '/coerce_nested_strings', ::Grape::Json.dump(values: [[]]), 'CONTENT_TYPE' => 'application/json'
+        expect(last_response.status).to eq(201)
+        expect(JSON.parse(last_response.body)).to eq([[]])
+
+        post '/coerce_nested_strings', ::Grape::Json.dump(values: [['a', { bar: 0 }], ['b']]), 'CONTENT_TYPE' => 'application/json'
+        expect(last_response.status).to eq(400)
       end
 
       it 'parses parameters with Array[Integer] type' do
@@ -484,6 +706,44 @@ describe Grape::Validations::CoerceValidator do
         expect(JSON.parse(last_response.body)).to eq([1, 1, 1, 1])
       end
 
+      context 'Array type and coerce_with should' do
+        before do
+          subject.params do
+            optional :arr, type: Array, coerce_with: (lambda do |val|
+              if val.nil?
+                []
+              else
+                val
+              end
+            end)
+          end
+          subject.get '/' do
+            params[:arr].class.to_s
+          end
+        end
+
+        it 'coerce nil value to array' do
+          get '/', arr: nil
+
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('Array')
+        end
+
+        it 'not coerce missing field' do
+          get '/'
+
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('NilClass')
+        end
+
+        it 'coerce array as array' do
+          get '/', arr: []
+
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('Array')
+        end
+      end
+
       it 'uses parse where available' do
         subject.params do
           requires :ints, type: Array, coerce_with: JSON do
@@ -532,6 +792,84 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.body).to eq('3')
       end
 
+      context 'Integer type and coerce_with should' do
+        before do
+          subject.params do
+            optional :int, type: Integer, coerce_with: (lambda do |val|
+              if val.nil?
+                0
+              else
+                val.to_i
+              end
+            end)
+          end
+          subject.get '/' do
+            params[:int].class.to_s
+          end
+        end
+
+        it 'coerce nil value to integer' do
+          get '/', int: nil
+
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('Integer')
+        end
+
+        it 'not coerce missing field' do
+          get '/'
+
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('NilClass')
+        end
+
+        it 'coerce integer as integer' do
+          get '/', int: 1
+
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('Integer')
+        end
+      end
+
+      context 'Integer type and coerce_with potentially returning nil' do
+        before do
+          subject.params do
+            requires :int, type: Integer, coerce_with: (lambda do |val|
+              if val == '0'
+                nil
+              elsif val.match?(/^-?\d+$/)
+                val.to_i
+              else
+                val
+              end
+            end)
+          end
+          subject.get '/' do
+            params[:int].class.to_s
+          end
+        end
+
+        it 'accepts value that coerces to nil' do
+          get '/', int: '0'
+
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('NilClass')
+        end
+
+        it 'coerces to Integer' do
+          get '/', int: '1'
+
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('Integer')
+        end
+
+        it 'returns invalid value if coercion returns a wrong type' do
+          get '/', int: 'lol'
+
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('int is invalid')
+        end
+      end
+
       it 'must be supplied with :type or :coerce' do
         expect do
           subject.params do
@@ -572,7 +910,7 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.status).to eq(200)
         expect(last_response.body).to eq('arrays work')
 
-        get '/', splines: [{ x: 2, ints: [] }, { x: 3, ints: [4], obj: { y: 'quack' } }]
+        get '/', splines: [{ x: 2, ints: [5] }, { x: 3, ints: [4], obj: { y: 'quack' } }]
         expect(last_response.status).to eq(200)
         expect(last_response.body).to eq('arrays work')
 
@@ -588,7 +926,7 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.status).to eq(400)
         expect(last_response.body).to eq('splines[x] does not have a valid value')
 
-        get '/', splines: [{ x: 1, ints: [] }, { x: 4, ints: [] }]
+        get '/', splines: [{ x: 1, ints: [5] }, { x: 4, ints: [6] }]
         expect(last_response.status).to eq(400)
         expect(last_response.body).to eq('splines[x] does not have a valid value')
       end
@@ -906,14 +1244,17 @@ describe Grape::Validations::CoerceValidator do
     end
 
     context 'converter' do
-      it 'does not build Virtus::Attribute multiple times' do
+      it 'does not build a coercer multiple times' do
         subject.params do
           requires :something, type: Array[String]
         end
         subject.get do
         end
 
-        expect(Virtus::Attribute).to receive(:build).at_most(2).times.and_call_original
+        expect(Grape::Validations::Types::ArrayCoercer).to(
+          receive(:new).at_most(:once).and_call_original
+        )
+
         10.times { get '/' }
       end
     end