grape 0.14.0 → 0.15.0

data/spec/grape/validations/params_scope_spec.rb

@@ -93,6 +93,7 @@ describe Grape::Validations::ParamsScope do
     module ParamsScopeSpec
       class CustomType
         attr_reader :value
+
         def self.parse(value)
           fail if value == 'invalid'
           new(value)
@@ -173,6 +174,24 @@ describe Grape::Validations::ParamsScope do
       end
     end
 
+    context 'when the default is an array' do
+      context 'and is the entire range of allowed values' do
+        it 'does not raise an exception' do
+          expect do
+            subject.params { optional :numbers, type: Array[Integer], values: 0..2, default: 0..2 }
+          end.to_not raise_error
+        end
+      end
+
+      context 'and is a subset of allowed values' do
+        it 'does not raise an exception' do
+          expect do
+            subject.params { optional :numbers, type: Array[Integer], values: [0, 1, 2], default: [1, 0] }
+          end.to_not raise_error
+        end
+      end
+    end
+
     context 'when both range endpoints are #kind_of? the type' do
       it 'accepts values in the range' do
         subject.params do
@@ -297,6 +316,32 @@ describe Grape::Validations::ParamsScope do
       expect(last_response.status).to eq(200)
     end
 
+    it 'applies the validations of multiple parameters' do
+      subject.params do
+        optional :a, :b
+        given :a, :b do
+          requires :c
+        end
+      end
+      subject.get('/multiple') { declared(params).to_json }
+
+      get '/multiple'
+      expect(last_response.status).to eq(200)
+
+      get '/multiple', a: true
+      expect(last_response.status).to eq(200)
+
+      get '/multiple', b: true
+      expect(last_response.status).to eq(200)
+
+      get '/multiple', a: true, b: true
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('c is missing')
+
+      get '/multiple', a: true, b: true, c: true
+      expect(last_response.status).to eq(200)
+    end
+
     it 'raises an error if the dependent parameter was never specified' do
       expect do
         subject.params do
@@ -327,5 +372,37 @@ describe Grape::Validations::ParamsScope do
       expect(last_response.status).to eq(400)
       expect(last_response.body).to eq('bar[b] is missing')
     end
+
+    it 'includes the nested parameter within #declared(params)' do
+      subject.params do
+        requires :bar, type: Hash do
+          optional :a
+          given :a do
+            requires :b
+          end
+        end
+      end
+      subject.get('/nested') { declared(params).to_json }
+
+      get '/nested', bar: { a: true, b: 'yes' }
+      expect(JSON.parse(last_response.body)).to eq('bar' => { 'a' => 'true', 'b' => 'yes' })
+    end
+
+    it 'includes level 2 nested parameters outside the given within #declared(params)' do
+      subject.params do
+        requires :bar, type: Hash do
+          optional :a
+          given :a do
+            requires :c, type: Hash do
+              requires :b
+            end
+          end
+        end
+      end
+      subject.get('/nested') { declared(params).to_json }
+
+      get '/nested', bar: { a: true, c: { b: 'yes' } }
+      expect(JSON.parse(last_response.body)).to eq('bar' => { 'a' => 'true', 'c' => { 'b' => 'yes' } })
+    end
   end
 end

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

@@ -120,6 +120,123 @@ describe Grape::Validations::AllowBlankValidator do
           end
         end
         get '/disallow_string_value_in_an_optional_hash_group'
+
+        resources :custom_message do
+          params do
+            requires :name, allow_blank: { value: false, message: 'has no value' }
+          end
+          get
+
+          params do
+            optional :name, allow_blank: { value: false, message: 'has no value' }
+          end
+          get '/disallow_blank_optional_param'
+
+          params do
+            requires :name, allow_blank: true
+          end
+          get '/allow_blank'
+
+          params do
+            requires :val, type: DateTime, allow_blank: true
+          end
+          get '/allow_datetime_blank'
+
+          params do
+            requires :val, type: DateTime, allow_blank: { value: false, message: 'has no value' }
+          end
+          get '/disallow_datetime_blank'
+
+          params do
+            requires :val, type: DateTime
+          end
+          get '/default_allow_datetime_blank'
+
+          params do
+            requires :val, type: Date, allow_blank: true
+          end
+          get '/allow_date_blank'
+
+          params do
+            requires :val, type: Integer, allow_blank: true
+          end
+          get '/allow_integer_blank'
+
+          params do
+            requires :val, type: Float, allow_blank: true
+          end
+          get '/allow_float_blank'
+
+          params do
+            requires :val, type: Fixnum, allow_blank: true
+          end
+          get '/allow_fixnum_blank'
+
+          params do
+            requires :val, type: Symbol, allow_blank: true
+          end
+          get '/allow_symbol_blank'
+
+          params do
+            requires :val, type: Boolean, allow_blank: true
+          end
+          get '/allow_boolean_blank'
+
+          params do
+            requires :val, type: Boolean, allow_blank: { value: false, message: 'has no value' }
+          end
+          get '/disallow_boolean_blank'
+
+          params do
+            optional :user, type: Hash do
+              requires :name, allow_blank: { value: false, message: 'has no value' }
+            end
+          end
+          get '/disallow_blank_required_param_in_an_optional_group'
+
+          params do
+            optional :user, type: Hash do
+              requires :name, type: Date, allow_blank: true
+            end
+          end
+          get '/allow_blank_date_param_in_an_optional_group'
+
+          params do
+            optional :user, type: Hash do
+              optional :name, allow_blank: { value: false, message: 'has no value' }
+              requires :age
+            end
+          end
+          get '/disallow_blank_optional_param_in_an_optional_group'
+
+          params do
+            requires :user, type: Hash do
+              requires :name, allow_blank: { value: false, message: 'has no value' }
+            end
+          end
+          get '/disallow_blank_required_param_in_a_required_group'
+
+          params do
+            requires :user, type: Hash do
+              requires :name, allow_blank: { value: false, message: 'has no value' }
+            end
+          end
+          get '/disallow_string_value_in_a_required_hash_group'
+
+          params do
+            requires :user, type: Hash do
+              optional :name, allow_blank: { value: false, message: 'has no value' }
+            end
+          end
+          get '/disallow_blank_optional_param_in_a_required_group'
+
+          params do
+            optional :user, type: Hash do
+              optional :name, allow_blank: { value: false, message: 'has no value' }
+            end
+          end
+          get '/disallow_string_value_in_an_optional_hash_group'
+        end
       end
     end
   end
@@ -154,6 +271,166 @@ describe Grape::Validations::AllowBlankValidator do
     end
   end
 
+  context 'custom validation message' do
+    context 'with invalid input' do
+      it 'refuses empty string' do
+        get '/custom_message', name: ''
+        expect(last_response.body).to eq('{"error":"name has no value"}')
+      end
+      it 'refuses empty string for an optional param' do
+        get '/custom_message/disallow_blank_optional_param', name: ''
+        expect(last_response.body).to eq('{"error":"name has no value"}')
+      end
+      it 'refuses only whitespaces' do
+        get '/custom_message', name: '   '
+        expect(last_response.body).to eq('{"error":"name has no value"}')
+
+        get '/custom_message', name: "  \n "
+        expect(last_response.body).to eq('{"error":"name has no value"}')
+
+        get '/custom_message', name: "\n"
+        expect(last_response.body).to eq('{"error":"name has no value"}')
+      end
+
+      it 'refuses nil' do
+        get '/custom_message', name: nil
+        expect(last_response.body).to eq('{"error":"name has no value"}')
+      end
+    end
+
+    context 'with valid input' do
+      it 'accepts valid input' do
+        get '/custom_message', name: 'bob'
+        expect(last_response.status).to eq(200)
+      end
+
+      it 'accepts empty input when allow_blank is false' do
+        get '/custom_message/allow_blank', name: ''
+        expect(last_response.status).to eq(200)
+      end
+
+      it 'accepts empty input' do
+        get '/custom_message/default_allow_datetime_blank', val: ''
+        expect(last_response.status).to eq(200)
+      end
+
+      it 'accepts empty when datetime allow_blank' do
+        get '/custom_message/allow_datetime_blank', val: ''
+        expect(last_response.status).to eq(200)
+      end
+
+      it 'accepts empty when date allow_blank' do
+        get '/custom_message/allow_date_blank', val: ''
+        expect(last_response.status).to eq(200)
+      end
+
+      context 'allow_blank when Numeric' do
+        it 'accepts empty when integer allow_blank' do
+          get '/custom_message/allow_integer_blank', val: ''
+          expect(last_response.status).to eq(200)
+        end
+
+        it 'accepts empty when float allow_blank' do
+          get '/custom_message/allow_float_blank', val: ''
+          expect(last_response.status).to eq(200)
+        end
+
+        it 'accepts empty when fixnum allow_blank' do
+          get '/custom_message/allow_fixnum_blank', val: ''
+          expect(last_response.status).to eq(200)
+        end
+      end
+
+      it 'accepts empty when symbol allow_blank' do
+        get '/custom_message/allow_symbol_blank', val: ''
+        expect(last_response.status).to eq(200)
+      end
+
+      it 'accepts empty when boolean allow_blank' do
+        get '/custom_message/allow_boolean_blank', val: ''
+        expect(last_response.status).to eq(200)
+      end
+
+      it 'accepts false when boolean allow_blank' do
+        get '/custom_message/disallow_boolean_blank', val: false
+        expect(last_response.status).to eq(200)
+      end
+    end
+
+    context 'in an optional group' do
+      context 'as a required param' do
+        it 'accepts a missing group, even with a disallwed blank param' do
+          get '/custom_message/disallow_blank_required_param_in_an_optional_group'
+          expect(last_response.status).to eq(200)
+        end
+
+        it 'accepts a nested missing date value' do
+          get '/custom_message/allow_blank_date_param_in_an_optional_group', user: { name: '' }
+          expect(last_response.status).to eq(200)
+        end
+
+        it 'refuses a blank value in an existing group' do
+          get '/custom_message/disallow_blank_required_param_in_an_optional_group', user: { name: '' }
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('{"error":"user[name] has no value"}')
+        end
+      end
+
+      context 'as an optional param' do
+        it 'accepts a missing group, even with a disallwed blank param' do
+          get '/custom_message/disallow_blank_optional_param_in_an_optional_group'
+          expect(last_response.status).to eq(200)
+        end
+
+        it 'accepts a nested missing optional value' do
+          get '/custom_message/disallow_blank_optional_param_in_an_optional_group', user: { age: '29' }
+          expect(last_response.status).to eq(200)
+        end
+
+        it 'refuses a blank existing value in an existing scope' do
+          get '/custom_message/disallow_blank_optional_param_in_an_optional_group', user: { age: '29', name: '' }
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('{"error":"user[name] has no value"}')
+        end
+      end
+    end
+
+    context 'in a required group' do
+      context 'as a required param' do
+        it 'refuses a blank value in a required existing group' do
+          get '/custom_message/disallow_blank_required_param_in_a_required_group', user: { name: '' }
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('{"error":"user[name] has no value"}')
+        end
+
+        it 'refuses a string value in a required hash group' do
+          get '/custom_message/disallow_string_value_in_a_required_hash_group', user: ''
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('{"error":"user is invalid, user[name] is missing"}')
+        end
+      end
+
+      context 'as an optional param' do
+        it 'accepts a nested missing value' do
+          get '/custom_message/disallow_blank_optional_param_in_a_required_group', user: { age: '29' }
+          expect(last_response.status).to eq(200)
+        end
+
+        it 'refuses a blank existing value in an existing scope' do
+          get '/custom_message/disallow_blank_optional_param_in_a_required_group', user: { age: '29', name: '' }
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('{"error":"user[name] has no value"}')
+        end
+
+        it 'refuses a string value in an optional hash group' do
+          get '/custom_message/disallow_string_value_in_an_optional_hash_group', user: ''
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('{"error":"user is invalid"}')
+        end
+      end
+    end
+  end
+
   context 'valid input' do
     it 'accepts valid input' do
       get '/', name: 'bob'

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

@@ -55,6 +55,62 @@ describe Grape::Validations::CoerceValidator do
       end
     end
 
+    context 'with a custom validation message' do
+      it 'errors on malformed input' do
+        subject.params do
+          requires :int, type: { value: Integer, message: 'type cast is invalid' }
+        end
+        subject.get '/single' do
+          'int works'
+        end
+
+        get '/single', int: '43a'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('int type cast is invalid')
+
+        get '/single', int: '43'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('int works')
+      end
+
+      context 'on custom coercion rules' 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'
+                true
+              elsif val == 'false'
+                0
+              else
+                val
+              end
+            end)
+          end
+          subject.get '/' do
+            params[:a].class.to_s
+          end
+        end
+
+        it 'respects :coerce_with' do
+          get '/', a: 'yup'
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('TrueClass')
+        end
+
+        it 'still validates type' do
+          get '/', a: 'false'
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('a type cast is invalid')
+        end
+
+        it 'performs no additional coercion' do
+          get '/', a: 'true'
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('String')
+        end
+      end
+    end
+
     it 'error on malformed input' do
       subject.params do
         requires :int, type: Integer
@@ -368,6 +424,41 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.body).to eq('splines[x] does not have a valid value')
       end
 
+      it 'works when declared optional' do
+        subject.params do
+          optional :splines, type: JSON do
+            requires :x, type: Integer, values: [1, 2, 3]
+            optional :ints, type: Array[Integer]
+            optional :obj, type: Hash do
+              optional :y
+            end
+          end
+        end
+        subject.get '/' do
+          if params[:splines].is_a? Hash
+            params[:splines][:obj][:y]
+          else
+            'arrays work' if params[:splines].any? { |s| s.key? :obj }
+          end
+        end
+
+        get '/', splines: '{"x":1,"ints":[1,2,3],"obj":{"y":"woof"}}'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('woof')
+
+        get '/', splines: '[{"x":2,"ints":[]},{"x":3,"ints":[4],"obj":{"y":"quack"}}]'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('arrays work')
+
+        get '/', splines: '{"x":4,"ints":[2]}'
+        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":[]}]'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('splines[x] does not have a valid value')
+      end
+
       it 'accepts Array[JSON] shorthand' do
         subject.params do
           requires :splines, type: Array[JSON] do