grape 1.2.5 → 1.4.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::DefaultValidator do
@@ -296,4 +298,125 @@ describe Grape::Validations::DefaultValidator do
       end
     end
   end
+
+  context 'optional with nil as value' do
+    subject do
+      Class.new(Grape::API) do
+        default_format :json
+      end
+    end
+
+    def app
+      subject
+    end
+
+    context 'primitive types' do
+      [
+        [Integer, 0],
+        [Integer, 42],
+        [Float, 0.0],
+        [Float, 4.2],
+        [BigDecimal, 0.0],
+        [BigDecimal, 4.2],
+        [Numeric, 0],
+        [Numeric, 42],
+        [Date, Date.today],
+        [DateTime, DateTime.now],
+        [Time, Time.now],
+        [Time, Time.at(0)],
+        [Grape::API::Boolean, false],
+        [String, ''],
+        [String, 'non-empty-string'],
+        [Symbol, :symbol],
+        [TrueClass, true],
+        [FalseClass, false]
+      ].each do |type, default|
+        it 'respects the default value' do
+          subject.params do
+            optional :param, type: type, default: default
+          end
+          subject.get '/default_value' do
+            params[:param]
+          end
+
+          get '/default_value', param: nil
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq(default.to_json)
+        end
+      end
+    end
+
+    context 'structures types' do
+      [
+        [Hash, {}],
+        [Hash, { test: 'non-empty' }],
+        [Array, []],
+        [Array, ['non-empty']],
+        [Array[Integer], []],
+        [Set, []],
+        [Set, [1]]
+      ].each do |type, default|
+        it 'respects the default value' do
+          subject.params do
+            optional :param, type: type, default: default
+          end
+          subject.get '/default_value' do
+            params[:param]
+          end
+
+          get '/default_value', param: nil
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq(default.to_json)
+        end
+      end
+    end
+
+    context 'special types' do
+      [
+        [JSON, ''],
+        [JSON, { test: 'non-empty-string' }.to_json],
+        [Array[JSON], []],
+        [Array[JSON], [{ test: 'non-empty-string' }.to_json]],
+        [::File, ''],
+        [::File, { test: 'non-empty-string' }.to_json],
+        [Rack::Multipart::UploadedFile, ''],
+        [Rack::Multipart::UploadedFile, { test: 'non-empty-string' }.to_json]
+      ].each do |type, default|
+        it 'respects the default value' do
+          subject.params do
+            optional :param, type: type, default: default
+          end
+          subject.get '/default_value' do
+            params[:param]
+          end
+
+          get '/default_value', param: nil
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq(default.to_json)
+        end
+      end
+    end
+
+    context 'variant-member-type collections' do
+      [
+        [Array[Integer, String], [0, '']],
+        [Array[Integer, String], [42, 'non-empty-string']],
+        [[Integer, String, Array[Integer, String]], [0, '', [0, '']]],
+        [[Integer, String, Array[Integer, String]], [42, 'non-empty-string', [42, 'non-empty-string']]]
+      ].each do |type, default|
+        it 'respects the default value' do
+          subject.params do
+            optional :param, type: type, default: default
+          end
+          subject.get '/default_value' do
+            params[:param]
+          end
+
+          get '/default_value', param: nil
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq(default.to_json)
+        end
+      end
+    end
+  end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::ExactlyOneOfValidator do
@@ -98,7 +100,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
         validate
         expect(last_response.status).to eq 400
         expect(JSON.parse(last_response.body)).to eq(
-          'beer,wine,grapefruit' => ['are missing, exactly one parameter must be provided']
+          'beer,wine,grapefruit' => ['are mutually exclusive']
         )
       end
 
@@ -110,7 +112,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
           validate
           expect(last_response.status).to eq 400
           expect(JSON.parse(last_response.body)).to eq(
-            'beer,wine,grapefruit' => ['are missing, exactly one parameter must be provided']
+            'beer,wine,grapefruit' => ['are mutually exclusive']
           )
         end
       end
@@ -124,7 +126,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
         validate
         expect(last_response.status).to eq 400
         expect(JSON.parse(last_response.body)).to eq(
-          'beer,wine,grapefruit' => ['are missing, exactly one parameter must be provided']
+          'beer,grapefruit' => ['are mutually exclusive']
         )
       end
     end
@@ -137,7 +139,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
         validate
         expect(last_response.status).to eq 400
         expect(JSON.parse(last_response.body)).to eq(
-          'beer,wine,grapefruit' => ['you should choose one']
+          'beer,wine' => ['you should choose one']
         )
       end
     end
@@ -173,7 +175,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
         validate
         expect(last_response.status).to eq 400
         expect(JSON.parse(last_response.body)).to eq(
-          'item[beer],item[wine],item[grapefruit]' => ['are missing, exactly one parameter must be provided']
+          'item[beer],item[wine]' => ['are mutually exclusive']
         )
       end
     end
@@ -188,7 +190,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
           validate
           expect(last_response.status).to eq 400
           expect(JSON.parse(last_response.body)).to eq(
-            'item[beer],item[wine],item[grapefruit]' => ['are missing, exactly one parameter must be provided']
+            'item[beer],item[wine]' => ['are mutually exclusive']
           )
         end
       end
@@ -211,11 +213,11 @@ describe Grape::Validations::ExactlyOneOfValidator do
         validate
         expect(last_response.status).to eq 400
         expect(JSON.parse(last_response.body)).to eq(
-          'items[0][beer],items[0][wine],items[0][grapefruit]' => [
-            'are missing, exactly one parameter must be provided'
+          'items[0][beer],items[0][wine]' => [
+            'are mutually exclusive'
           ],
-          'items[1][beer],items[1][wine],items[1][grapefruit]' => [
-            'are missing, exactly one parameter must be provided'
+          'items[1][wine],items[1][grapefruit]' => [
+            'are mutually exclusive'
           ]
         )
       end
@@ -229,8 +231,8 @@ describe Grape::Validations::ExactlyOneOfValidator 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]' => [
-            'are missing, exactly one parameter must be provided'
+          'items[0][nested_items][0][beer],items[0][nested_items][0][wine]' => [
+            'are mutually exclusive'
           ]
         )
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::ExceptValuesValidator do
@@ -110,7 +112,7 @@ describe Grape::Validations::ExceptValuesValidator do
         optional: { type: Array[Integer], except_values: [10, 11], default: 12 },
         tests: [
           { value: 'invalid-type1', rc: 400, body: { error: 'type is invalid' }.to_json },
-          { value: 10, rc: 400, body: { error: 'type has a value not allowed' }.to_json },
+          { value: 10, rc: 400, body: { error: 'type is invalid' }.to_json },
           { value: [10], rc: 400, body: { error: 'type has a value not allowed' }.to_json },
           { value: ['3'], rc: 200, body: { type: [3] }.to_json },
           { value: [3], rc: 200, body: { type: [3] }.to_json },

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::MutualExclusionValidator do

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::PresenceValidator do
@@ -269,4 +271,32 @@ describe Grape::Validations::PresenceValidator do
       expect(last_response.body).to eq('Hello optional'.to_json)
     end
   end
+
+  context 'with a custom type' do
+    it 'does not validate their type when it is missing' do
+      class CustomType
+        def self.parse(value)
+          return if value.blank?
+
+          new
+        end
+      end
+
+      subject.params do
+        requires :custom, type: CustomType
+      end
+      subject.get '/custom' do
+        'custom'
+      end
+
+      get 'custom'
+
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('{"error":"custom is missing"}')
+
+      get 'custom', custom: 'filled'
+
+      expect(last_response.status).to eq(200)
+    end
+  end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::RegexpValidator do

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::SameAsValidator do

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::ValuesValidator do
@@ -222,6 +224,11 @@ describe Grape::Validations::ValuesValidator do
           requires :type, values: { proc: ->(v) { ValuesModel.values.include? v }, message: 'failed check' }
         end
         get '/proc/message'
+
+        params do
+          optional :name, type: String, values: %w[a b], allow_blank: true
+        end
+        get '/allow_blank'
       end
     end
   end
@@ -312,7 +319,7 @@ describe Grape::Validations::ValuesValidator do
       expect(last_response.status).to eq 200
     end
 
-    it 'allows for an optional param with a list of values' do
+    it 'accepts for an optional param with a list of values' do
       put('/optional_with_array_of_string_values', optional: nil)
       expect(last_response.status).to eq 200
     end
@@ -431,11 +438,21 @@ describe Grape::Validations::ValuesValidator do
     end.to raise_error Grape::Exceptions::IncompatibleOptionValues
   end
 
-  it 'allows values to be true or false when setting the type to boolean' do
-    get('/values/optional_boolean', type: true)
-    expect(last_response.status).to eq 200
-    expect(last_response.body).to eq({ type: true }.to_json)
+  context 'boolean values' do
+    it 'allows a value from the list' do
+      get('/values/optional_boolean', type: true)
+
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq({ type: true }.to_json)
+    end
+
+    it 'rejects a value which is not in the list' do
+      get('/values/optional_boolean', type: false)
+
+      expect(last_response.body).to eq({ error: 'type does not have a valid value' }.to_json)
+    end
   end
+
   it 'allows values to be a kind of the coerced type not just an instance of it' do
     get('/values/coercion', type: 10)
     expect(last_response.status).to eq 200
@@ -462,6 +479,14 @@ describe Grape::Validations::ValuesValidator do
     end.to raise_error Grape::Exceptions::IncompatibleOptionValues
   end
 
+  it 'allows a blank value when the allow_blank option is true' do
+    get 'allow_blank', name: nil
+    expect(last_response.status).to eq(200)
+
+    get 'allow_blank', name: ''
+    expect(last_response.status).to eq(200)
+  end
+
   context 'with a lambda values' do
     subject do
       Class.new(Grape::API) do

data/spec/grape/validations_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations do
@@ -7,16 +9,23 @@ describe Grape::Validations do
     subject
   end
 
+  def declared_params
+    subject.namespace_stackable(:declared_params).flatten
+  end
+
   describe 'params' do
     context 'optional' do
-      it 'validates when params is present' do
+      before do
         subject.params do
           optional :a_number, regexp: /^[0-9]+$/
+          optional :attachment, type: File
         end
         subject.get '/optional' do
           'optional works!'
         end
+      end
 
+      it 'validates when params is present' do
         get '/optional', a_number: 'string'
         expect(last_response.status).to eq(400)
         expect(last_response.body).to eq('a_number is invalid')
@@ -27,14 +36,7 @@ describe Grape::Validations do
       end
 
       it "doesn't validate when param not present" do
-        subject.params do
-          optional :a_number, regexp: /^[0-9]+$/
-        end
-        subject.get '/optional' do
-          'optional works!'
-        end
-
-        get '/optional'
+        get '/optional', a_number: nil, attachment: nil
         expect(last_response.status).to eq(200)
         expect(last_response.body).to eq('optional works!')
       end
@@ -43,7 +45,7 @@ describe Grape::Validations do
         subject.params do
           optional :some_param
         end
-        expect(subject.route_setting(:declared_params)).to eq([:some_param])
+        expect(declared_params).to eq([:some_param])
       end
     end
 
@@ -63,7 +65,7 @@ describe Grape::Validations do
 
       it 'adds entity documentation to declared params' do
         define_optional_using
-        expect(subject.route_setting(:declared_params)).to eq(%i[field_a field_b])
+        expect(declared_params).to eq(%i[field_a field_b])
       end
 
       it 'works when field_a and field_b are not present' do
@@ -110,7 +112,7 @@ describe Grape::Validations do
         subject.params do
           requires :some_param
         end
-        expect(subject.route_setting(:declared_params)).to eq([:some_param])
+        expect(declared_params).to eq([:some_param])
       end
 
       it 'works when required field is present but nil' do
@@ -120,6 +122,62 @@ describe Grape::Validations do
       end
     end
 
+    context 'requires with nested params' do
+      before do
+        subject.params do
+          requires :first_level, type: Hash do
+            optional :second_level, type: Array do
+              requires :value, type: Integer
+              optional :name, type: String
+              optional :third_level, type: Array do
+                requires :value, type: Integer
+                optional :name, type: String
+                optional :fourth_level, type: Array do
+                  requires :value, type: Integer
+                  optional :name, type: String
+                end
+              end
+            end
+          end
+        end
+        subject.put('/required') { 'required works' }
+      end
+
+      let(:request_params) do
+        {
+          first_level: {
+            second_level: [
+              { value: 1, name: 'Lisa' },
+              {
+                value: 2,
+                name: 'James',
+                third_level: [
+                  { value: 'three', name: 'Sophie' },
+                  {
+                    value: 4,
+                    name: 'Jenny',
+                    fourth_level: [
+                      { name: 'Samuel' }, { value: 6, name: 'Jane' }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      end
+
+      it 'validates correctly in deep nested params' do
+        put '/required', request_params.to_json, 'CONTENT_TYPE' => 'application/json'
+
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq(
+          'first_level[second_level][1][third_level][0][value] is invalid, ' \
+          'first_level[second_level][1][third_level][1][fourth_level][0][value] is missing'
+        )
+      end
+    end
+
     context 'requires :all using Grape::Entity documentation' do
       def define_requires_all
         documentation = {
@@ -139,7 +197,7 @@ describe Grape::Validations do
 
       it 'adds entity documentation to declared params' do
         define_requires_all
-        expect(subject.route_setting(:declared_params)).to eq(%i[required_field optional_field])
+        expect(declared_params).to eq(%i[required_field optional_field])
       end
 
       it 'errors when required_field is not present' do
@@ -174,7 +232,7 @@ describe Grape::Validations do
 
       it 'adds entity documentation to declared params' do
         define_requires_none
-        expect(subject.route_setting(:declared_params)).to eq(%i[required_field optional_field])
+        expect(declared_params).to eq(%i[required_field optional_field])
       end
 
       it 'errors when required_field is not present' do
@@ -204,7 +262,7 @@ describe Grape::Validations do
 
         it 'adds only the entity documentation to declared params, nothing more' do
           define_requires_all
-          expect(subject.route_setting(:declared_params)).to eq(%i[required_field optional_field])
+          expect(declared_params).to eq(%i[required_field optional_field])
         end
       end
 
@@ -270,7 +328,7 @@ describe Grape::Validations do
             requires :key
           end
         end
-        expect(subject.route_setting(:declared_params)).to eq([items: [:key]])
+        expect(declared_params).to eq([items: [:key]])
       end
     end
 
@@ -342,7 +400,7 @@ describe Grape::Validations do
             requires :key
           end
         end
-        expect(subject.route_setting(:declared_params)).to eq([items: [:key]])
+        expect(declared_params).to eq([items: [:key]])
       end
     end
 
@@ -405,7 +463,7 @@ describe Grape::Validations do
             requires :key
           end
         end
-        expect(subject.route_setting(:declared_params)).to eq([items: [:key]])
+        expect(declared_params).to eq([items: [:key]])
       end
     end
 
@@ -436,7 +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, params: [@scope.full_name(attr_name)], message: "'from' must be lower or equal to 'to'"
+              raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: "'from' must be lower or equal to 'to'")
             end
           end
         end
@@ -520,7 +578,7 @@ describe Grape::Validations do
         # NOTE: with body parameters in json or XML or similar this
         # should actually fail with: children[parents][name] is missing.
         expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('children[1][parents] is missing')
+        expect(last_response.body).to eq('children[1][parents] is missing, children[0][parents][1][name] is missing, children[0][parents][1][name] is empty')
       end
 
       it 'errors when a parameter is not present in array within array' do
@@ -561,7 +619,7 @@ describe Grape::Validations do
 
         get '/within_array', children: [name: 'Jay']
         expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('children[0][parents] is missing')
+        expect(last_response.body).to eq('children[0][parents] is missing, children[0][parents][0][name] is missing, children[0][parents][0][name] is empty')
       end
 
       it 'errors when param is not an Array' do
@@ -709,7 +767,7 @@ describe Grape::Validations do
         expect(last_response.status).to eq(200)
         put_with_json '/within_array', children: [name: 'Jay']
         expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('children[0][parents] is missing')
+        expect(last_response.body).to eq('children[0][parents] is missing, children[0][parents][0][name] is missing')
       end
     end
 
@@ -759,7 +817,7 @@ describe Grape::Validations do
             requires :key
           end
         end
-        expect(subject.route_setting(:declared_params)).to eq([items: [:key]])
+        expect(declared_params).to eq([items: [:key]])
       end
     end
 
@@ -784,7 +842,7 @@ describe Grape::Validations do
       it 'does internal validations if the outer group is present' do
         get '/nested_optional_group', items: [{ key: 'foo' }]
         expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('items[0][required_subitems] is missing')
+        expect(last_response.body).to eq('items[0][required_subitems] is missing, items[0][required_subitems][0][value] is missing')
 
         get '/nested_optional_group', items: [{ key: 'foo', required_subitems: [{ value: 'bar' }] }]
         expect(last_response.status).to eq(200)
@@ -804,7 +862,7 @@ describe Grape::Validations do
       it 'handles validation within arrays' do
         get '/nested_optional_group', items: [{ key: 'foo' }]
         expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('items[0][required_subitems] is missing')
+        expect(last_response.body).to eq('items[0][required_subitems] is missing, items[0][required_subitems][0][value] is missing')
 
         get '/nested_optional_group', items: [{ key: 'foo', required_subitems: [{ value: 'bar' }] }]
         expect(last_response.status).to eq(200)
@@ -823,7 +881,7 @@ describe Grape::Validations do
             requires(:required_subitems, type: Array) { requires :value }
           end
         end
-        expect(subject.route_setting(:declared_params)).to eq([items: [:key, { optional_subitems: [:value] }, { required_subitems: [:value] }]])
+        expect(declared_params).to eq([items: [:key, { optional_subitems: [:value] }, { required_subitems: [:value] }]])
       end
     end
 
@@ -851,7 +909,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, params: [@scope.full_name(attr_name)], message: 'is not custom!'
+            raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: 'is not custom!')
           end
         end
       end
@@ -999,7 +1057,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, params: [@scope.full_name(attr_name)], message: message
+              raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message)
             end
           end
         end
@@ -1068,14 +1126,14 @@ describe Grape::Validations do
           subject.params do
             use :pagination
           end
-          expect(subject.route_setting(:declared_params)).to eq %i[page per_page]
+          expect(declared_params).to eq %i[page per_page]
         end
 
         it 'by #use with multiple params' do
           subject.params do
             use :pagination, :period
           end
-          expect(subject.route_setting(:declared_params)).to eq %i[page per_page start_date end_date]
+          expect(declared_params).to eq %i[page per_page start_date end_date]
         end
       end
 
@@ -1364,7 +1422,7 @@ describe Grape::Validations do
           it 'errors when two or more are present' do
             get '/custom_message/exactly_one_of', beer: 'string', wine: 'anotherstring'
             expect(last_response.status).to eq(400)
-            expect(last_response.body).to eq 'beer, wine, juice are missing, exactly one parameter is required'
+            expect(last_response.body).to eq 'beer, wine are missing, exactly one parameter is required'
           end
         end
 
@@ -1383,7 +1441,7 @@ describe Grape::Validations do
         it 'errors when two or more are present' do
           get '/exactly_one_of', beer: 'string', wine: 'anotherstring'
           expect(last_response.status).to eq(400)
-          expect(last_response.body).to eq 'beer, wine, juice are missing, exactly one parameter must be provided'
+          expect(last_response.body).to eq 'beer, wine are mutually exclusive'
         end
       end
 
@@ -1423,7 +1481,7 @@ describe Grape::Validations do
         it 'errors when two or more are present' do
           get '/exactly_one_of_nested', nested: { beer_nested: 'string' }, nested2: [{ beer_nested2: 'string', wine_nested2: 'anotherstring' }]
           expect(last_response.status).to eq(400)
-          expect(last_response.body).to eq 'nested2[0][beer_nested2], nested2[0][wine_nested2], nested2[0][juice_nested2] are missing, exactly one parameter must be provided'
+          expect(last_response.body).to eq 'nested2[0][beer_nested2], nested2[0][wine_nested2] are mutually exclusive'
         end
       end
     end