grape 1.5.0 → 1.6.0

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

@@ -31,9 +31,9 @@ describe Grape::Validations::CoerceValidator do
 
       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.load_path << File.expand_path('zh-CN.yml', __dir__)
         I18n.reload!
-        I18n.locale = 'zh-CN'.to_sym
+        I18n.locale = :'zh-CN'
         subject.params do
           requires :age, type: Integer
         end
@@ -48,7 +48,7 @@ describe Grape::Validations::CoerceValidator do
 
       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
+        I18n.locale = :'pt-BR'
         subject.params do
           requires :age, type: Integer
         end
@@ -84,9 +84,10 @@ describe Grape::Validations::CoerceValidator do
         before do
           subject.params do
             requires :a, types: { value: [Boolean, String], message: 'type cast is invalid' }, coerce_with: (lambda do |val|
-              if val == 'yup'
+              case val
+              when 'yup'
                 true
-              elsif val == 'false'
+              when 'false'
                 0
               else
                 val
@@ -227,23 +228,51 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.body).to eq('NilClass')
       end
 
-      it 'is a custom type' do
-        subject.params do
-          requires :uri, coerce: SecureURIOnly
-        end
-        subject.get '/secure_uri' do
-          params[:uri].class
+      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
 
-        get 'secure_uri', uri: 'https://www.example.com'
+        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
 
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('URI::HTTPS')
+            subject.params do
+              requires :name, type: type
+            end
+            subject.get '/whatever' do
+              params[:name].class
+            end
 
-        get 'secure_uri', uri: 'http://www.example.com'
+            get 'whatever', name: 'Bob'
 
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('uri is invalid')
+            expect(last_response.status).to eq(400)
+            expect(last_response.body).to eq('name must be unique')
+          end
+        end
       end
 
       context 'Array' do
@@ -622,7 +651,7 @@ describe Grape::Validations::CoerceValidator do
 
       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 }
+          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]
@@ -678,6 +707,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
@@ -726,13 +793,52 @@ 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'
+              case val
+              when '0'
                 nil
-              elsif val.match?(/^-?\d+$/)
+              when /^-?\d+$/
                 val.to_i
               else
                 val
@@ -1097,9 +1203,10 @@ describe Grape::Validations::CoerceValidator do
         before do
           subject.params do
             requires :a, types: [Boolean, String], coerce_with: (lambda do |val|
-              if val == 'yup'
+              case val
+              when 'yup'
                 true
-              elsif val == 'false'
+              when 'false'
                 0
               else
                 val

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

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Grape::Validations::ExceptValuesValidator do
   module ValidationsSpec
     class ExceptValuesModel
-      DEFAULT_EXCEPTS = ['invalid-type1', 'invalid-type2', 'invalid-type3'].freeze
+      DEFAULT_EXCEPTS = %w[invalid-type1 invalid-type2 invalid-type3].freeze
       class << self
         attr_accessor :excepts
 
@@ -170,7 +170,7 @@ describe Grape::Validations::ExceptValuesValidator do
   it 'raises IncompatibleOptionValues when type is incompatible with values array' do
     subject = Class.new(Grape::API)
     expect do
-      subject.params { optional :type, except_values: ['valid-type1', 'valid-type2', 'valid-type3'], type: Symbol }
+      subject.params { optional :type, except_values: %w[valid-type1 valid-type2 valid-type3], type: Symbol }
     end.to raise_error Grape::Exceptions::IncompatibleOptionValues
   end
 

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

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Grape::Validations::ValuesValidator do
   module ValidationsSpec
     class ValuesModel
-      DEFAULT_VALUES = ['valid-type1', 'valid-type2', 'valid-type3'].freeze
-      DEFAULT_EXCEPTS = ['invalid-type1', 'invalid-type2', 'invalid-type3'].freeze
+      DEFAULT_VALUES = %w[valid-type1 valid-type2 valid-type3].freeze
+      DEFAULT_EXCEPTS = %w[invalid-type1 invalid-type2 invalid-type3].freeze
       class << self
         def values
           @values ||= []
@@ -27,6 +27,10 @@ describe Grape::Validations::ValuesValidator do
           @excepts ||= []
           @excepts << except
         end
+
+        def include?(value)
+          values.include?(value)
+        end
       end
     end
 
@@ -106,7 +110,7 @@ describe Grape::Validations::ValuesValidator do
         end
 
         params do
-          requires :type, values: ->(v) { ValuesModel.values.include? v }
+          requires :type, values: ->(v) { ValuesModel.include? v }
         end
         get '/lambda_val' do
           { type: params[:type] }
@@ -214,14 +218,14 @@ describe Grape::Validations::ValuesValidator do
         put '/optional_with_array_of_string_values'
 
         params do
-          requires :type, values: { proc: ->(v) { ValuesModel.values.include? v } }
+          requires :type, values: { proc: ->(v) { ValuesModel.include? v } }
         end
         get '/proc' do
           { type: params[:type] }
         end
 
         params do
-          requires :type, values: { proc: ->(v) { ValuesModel.values.include? v }, message: 'failed check' }
+          requires :type, values: { proc: ->(v) { ValuesModel.include? v }, message: 'failed check' }
         end
         get '/proc/message'
 
@@ -420,21 +424,21 @@ describe Grape::Validations::ValuesValidator do
   it 'raises IncompatibleOptionValues on an invalid default value from proc' do
     subject = Class.new(Grape::API)
     expect do
-      subject.params { optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], default: ValidationsSpec::ValuesModel.values.sample + '_invalid' }
+      subject.params { optional :type, values: %w[valid-type1 valid-type2 valid-type3], default: "#{ValidationsSpec::ValuesModel.values.sample}_invalid" }
     end.to raise_error Grape::Exceptions::IncompatibleOptionValues
   end
 
   it 'raises IncompatibleOptionValues on an invalid default value' do
     subject = Class.new(Grape::API)
     expect do
-      subject.params { optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], default: 'invalid-type' }
+      subject.params { optional :type, values: %w[valid-type1 valid-type2 valid-type3], default: 'invalid-type' }
     end.to raise_error Grape::Exceptions::IncompatibleOptionValues
   end
 
   it 'raises IncompatibleOptionValues when type is incompatible with values array' do
     subject = Class.new(Grape::API)
     expect do
-      subject.params { optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], type: Symbol }
+      subject.params { optional :type, values: %w[valid-type1 valid-type2 valid-type3], type: Symbol }
     end.to raise_error Grape::Exceptions::IncompatibleOptionValues
   end
 
@@ -648,9 +652,9 @@ describe Grape::Validations::ValuesValidator do
     end
 
     it 'accepts multiple valid values' do
-      get '/proc', type: ['valid-type1', 'valid-type3']
+      get '/proc', type: %w[valid-type1 valid-type3]
       expect(last_response.status).to eq 200
-      expect(last_response.body).to eq({ type: ['valid-type1', 'valid-type3'] }.to_json)
+      expect(last_response.body).to eq({ type: %w[valid-type1 valid-type3] }.to_json)
     end
 
     it 'rejects a single invalid value' do
@@ -660,7 +664,7 @@ describe Grape::Validations::ValuesValidator do
     end
 
     it 'rejects an invalid value among valid ones' do
-      get '/proc', type: ['valid-type1', 'invalid-type1', 'valid-type3']
+      get '/proc', type: %w[valid-type1 invalid-type1 valid-type3]
       expect(last_response.status).to eq 400
       expect(last_response.body).to eq({ error: 'type does not have a valid value' }.to_json)
     end

data/spec/grape/validations_spec.rb

@@ -494,6 +494,7 @@ describe Grape::Validations do
           class DateRangeValidator < Grape::Validations::Base
             def validate_param!(attr_name, params)
               return if params[attr_name][:from] <= params[attr_name][:to]
+
               raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: "'from' must be lower or equal to 'to'")
             end
           end
@@ -883,6 +884,283 @@ describe Grape::Validations do
         end
         expect(declared_params).to eq([items: [:key, { optional_subitems: [:value] }, { required_subitems: [:value] }]])
       end
+
+      context <<~DESC do
+        Issue occurs whenever:
+        * param structure with at least three levels
+        * 1st level item is a required Array that has >1 entry with an optional item present and >1 entry with an optional item missing#{'  '}
+        * 2nd level is an optional Array or Hash#{' '}
+        * 3rd level is a required item (can be any type)
+        * additional levels do not effect the issue from occuring
+      DESC
+
+        it 'example based off actual real world use case' do
+          subject.params do
+            requires :orders, type: Array do
+              requires :id, type: Integer
+              optional :drugs, type: Array do
+                requires :batches, type: Array do
+                  requires :batch_no, type: String
+                end
+              end
+            end
+          end
+
+          subject.get '/validate_required_arrays_under_optional_arrays' do
+            'validate_required_arrays_under_optional_arrays works!'
+          end
+
+          data = {
+            orders: [
+              { id: 77, drugs: [{ batches: [{ batch_no: 'A1234567' }] }] },
+              { id: 70 }
+            ]
+          }
+
+          get '/validate_required_arrays_under_optional_arrays', data
+          expect(last_response.body).to eq('validate_required_arrays_under_optional_arrays works!')
+          expect(last_response.status).to eq(200)
+        end
+
+        it 'simplest example using Array -> Array -> Hash -> String' do
+          subject.params do
+            requires :orders, type: Array do
+              requires :id, type: Integer
+              optional :drugs, type: Array do
+                requires :batch_no, type: String
+              end
+            end
+          end
+
+          subject.get '/validate_required_arrays_under_optional_arrays' do
+            'validate_required_arrays_under_optional_arrays works!'
+          end
+
+          data = {
+            orders: [
+              { id: 77, drugs: [{ batch_no: 'A1234567' }] },
+              { id: 70 }
+            ]
+          }
+
+          get '/validate_required_arrays_under_optional_arrays', data
+          expect(last_response.body).to eq('validate_required_arrays_under_optional_arrays works!')
+          expect(last_response.status).to eq(200)
+        end
+
+        it 'simplest example using Array -> Hash -> String' do
+          subject.params do
+            requires :orders, type: Array do
+              requires :id, type: Integer
+              optional :drugs, type: Hash do
+                requires :batch_no, type: String
+              end
+            end
+          end
+
+          subject.get '/validate_required_arrays_under_optional_arrays' do
+            'validate_required_arrays_under_optional_arrays works!'
+          end
+
+          data = {
+            orders: [
+              { id: 77, drugs: { batch_no: 'A1234567' } },
+              { id: 70 }
+            ]
+          }
+
+          get '/validate_required_arrays_under_optional_arrays', data
+          expect(last_response.body).to eq('validate_required_arrays_under_optional_arrays works!')
+          expect(last_response.status).to eq(200)
+        end
+
+        it 'correctly indexes invalida data' do
+          subject.params do
+            requires :orders, type: Array do
+              requires :id, type: Integer
+              optional :drugs, type: Array do
+                requires :batch_no, type: String
+                requires :quantity, type: Integer
+              end
+            end
+          end
+
+          subject.get '/correctly_indexes' do
+            'correctly_indexes works!'
+          end
+
+          data = {
+            orders: [
+              { id: 70 },
+              { id: 77, drugs: [{ batch_no: 'A1234567', quantity: 12 }, { batch_no: 'B222222' }] }
+            ]
+          }
+
+          get '/correctly_indexes', data
+          expect(last_response.body).to eq('orders[1][drugs][1][quantity] is missing')
+          expect(last_response.status).to eq(400)
+        end
+
+        context 'multiple levels of optional and requires settings' do
+          before do
+            subject.params do
+              requires :top, type: Array do
+                requires :top_id, type: Integer, allow_blank: false
+                optional :middle_1, type: Array do
+                  requires :middle_1_id, type: Integer, allow_blank: false
+                  optional :middle_2, type: Array do
+                    requires :middle_2_id, type: String, allow_blank: false
+                    optional :bottom, type: Array do
+                      requires :bottom_id, type: Integer, allow_blank: false
+                    end
+                  end
+                end
+              end
+            end
+
+            subject.get '/multi_level' do
+              'multi_level works!'
+            end
+          end
+
+          it 'with valid data' do
+            data = {
+              top: [
+                { top_id: 1, middle_1: [
+                  { middle_1_id: 11 }, { middle_1_id: 12, middle_2: [
+                    { middle_2_id: 121 }, { middle_2_id: 122, bottom: [{ bottom_id: 1221 }] }
+                  ] }
+                ] },
+                { top_id: 2, middle_1: [
+                  { middle_1_id: 21 }, { middle_1_id: 22, middle_2: [
+                    { middle_2_id: 221 }
+                  ] }
+                ] },
+                { top_id: 3, middle_1: [
+                  { middle_1_id: 31 }, { middle_1_id: 32 }
+                ] },
+                { top_id: 4 }
+              ]
+            }
+
+            get '/multi_level', data
+            expect(last_response.body).to eq('multi_level works!')
+            expect(last_response.status).to eq(200)
+          end
+
+          it 'with invalid data' do
+            data = {
+              top: [
+                { top_id: 1, middle_1: [
+                  { middle_1_id: 11 }, { middle_1_id: 12, middle_2: [
+                    { middle_2_id: 121 }, { middle_2_id: 122, bottom: [{ bottom_id: nil }] }
+                  ] }
+                ] },
+                { top_id: 2, middle_1: [
+                  { middle_1_id: 21 }, { middle_1_id: 22, middle_2: [{ middle_2_id: nil }] }
+                ] },
+                { top_id: 3, middle_1: [
+                  { middle_1_id: nil }, { middle_1_id: 32 }
+                ] },
+                { top_id: nil, missing_top_id: 4 }
+              ]
+            }
+            # 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.status).to eq(400)
+          end
+        end
+      end
+
+      it 'exactly_one_of' do
+        subject.params do
+          requires :orders, type: Array do
+            requires :id, type: Integer
+            optional :drugs, type: Hash do
+              optional :batch_no, type: String
+              optional :batch_id, type: String
+              exactly_one_of :batch_no, :batch_id
+            end
+          end
+        end
+
+        subject.get '/exactly_one_of' do
+          'exactly_one_of works!'
+        end
+
+        data = {
+          orders: [
+            { id: 77, drugs: { batch_no: 'A1234567' } },
+            { id: 70 }
+          ]
+        }
+
+        get '/exactly_one_of', data
+        expect(last_response.body).to eq('exactly_one_of works!')
+        expect(last_response.status).to eq(200)
+      end
+
+      it 'at_least_one_of' do
+        subject.params do
+          requires :orders, type: Array do
+            requires :id, type: Integer
+            optional :drugs, type: Hash do
+              optional :batch_no, type: String
+              optional :batch_id, type: String
+              at_least_one_of :batch_no, :batch_id
+            end
+          end
+        end
+
+        subject.get '/at_least_one_of' do
+          'at_least_one_of works!'
+        end
+
+        data = {
+          orders: [
+            { id: 77, drugs: { batch_no: 'A1234567' } },
+            { id: 70 }
+          ]
+        }
+
+        get '/at_least_one_of', data
+        expect(last_response.body).to eq('at_least_one_of works!')
+        expect(last_response.status).to eq(200)
+      end
+
+      it 'all_or_none_of' do
+        subject.params do
+          requires :orders, type: Array do
+            requires :id, type: Integer
+            optional :drugs, type: Hash do
+              optional :batch_no, type: String
+              optional :batch_id, type: String
+              all_or_none_of :batch_no, :batch_id
+            end
+          end
+        end
+
+        subject.get '/all_or_none_of' do
+          'all_or_none_of works!'
+        end
+
+        data = {
+          orders: [
+            { id: 77, drugs: { batch_no: 'A1234567', batch_id: '12' } },
+            { id: 70 }
+          ]
+        }
+
+        get '/all_or_none_of', data
+        expect(last_response.body).to eq('all_or_none_of works!')
+        expect(last_response.status).to eq(200)
+      end
     end
 
     context 'multiple validation errors' do
@@ -909,6 +1187,7 @@ describe Grape::Validations do
         class Customvalidator < Grape::Validations::Base
           def validate_param!(attr_name, params)
             return if params[attr_name] == 'im custom'
+
             raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: 'is not custom!')
           end
         end
@@ -1057,6 +1336,7 @@ describe Grape::Validations do
           class CustomvalidatorWithOptions < Grape::Validations::Base
             def validate_param!(attr_name, params)
               return if params[attr_name] == @option[:text]
+
               raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message)
             end
           end