grape 1.1.0 → 1.5.3

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
@@ -6,6 +8,7 @@ describe Grape::Validations::ExceptValuesValidator do
       DEFAULT_EXCEPTS = ['invalid-type1', 'invalid-type2', 'invalid-type3'].freeze
       class << self
         attr_accessor :excepts
+
         def excepts
           @excepts ||= []
           [DEFAULT_EXCEPTS + @excepts].flatten.uniq
@@ -110,7 +113,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,62 +1,221 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::MutualExclusionValidator do
   describe '#validate!' do
-    let(:scope) do
-      Struct.new(:opts) do
-        def params(arg)
-          arg
+    subject(:validate) { post path, params }
+
+    module ValidationsSpec
+      module MutualExclusionValidatorSpec
+        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
+            optional :wine
+            optional :grapefruit
+            mutually_exclusive :beer, :wine, :grapefruit
+          end
+          post do
+          end
+
+          params do
+            optional :beer
+            optional :wine
+            optional :grapefruit
+            optional :other
+            mutually_exclusive :beer, :wine, :grapefruit
+          end
+          post 'mixed-params' do
+          end
+
+          params do
+            optional :beer
+            optional :wine
+            optional :grapefruit
+            mutually_exclusive :beer, :wine, :grapefruit, message: 'you should not mix beer and wine'
+          end
+          post '/custom-message' do
+          end
+
+          params do
+            requires :item, type: Hash do
+              optional :beer
+              optional :wine
+              optional :grapefruit
+              mutually_exclusive :beer, :wine, :grapefruit
+            end
+          end
+          post '/nested-hash' do
+          end
+
+          params do
+            optional :item, type: Hash do
+              optional :beer
+              optional :wine
+              optional :grapefruit
+              mutually_exclusive :beer, :wine, :grapefruit
+            end
+          end
+          post '/nested-optional-hash' do
+          end
+
+          params do
+            requires :items, type: Array do
+              optional :beer
+              optional :wine
+              optional :grapefruit
+              mutually_exclusive :beer, :wine, :grapefruit
+            end
+          end
+          post '/nested-array' do
+          end
+
+          params do
+            requires :items, type: Array do
+              requires :nested_items, type: Array do
+                optional :beer, :wine, :grapefruit, type: Boolean
+                mutually_exclusive :beer, :wine, :grapefruit
+              end
+            end
+          end
+          post '/deeply-nested-array' do
+          end
         end
       end
     end
-    let(:mutually_exclusive_params) { %i[beer wine grapefruit] }
-    let(:validator) { described_class.new(mutually_exclusive_params, {}, false, scope.new) }
+
+    def app
+      ValidationsSpec::MutualExclusionValidatorSpec::API
+    end
 
     context 'when all mutually exclusive params are present' do
+      let(:path) { '/' }
       let(:params) { { beer: true, wine: true, grapefruit: true } }
 
-      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' => ['are mutually exclusive']
+        )
       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 'still raises a validation exception' do
-          expect do
-            validator.validate! mixed_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' => ['are mutually exclusive']
+          )
         end
       end
     end
 
     context 'when a subset of mutually exclusive params are present' do
+      let(:path) { '/' }
       let(:params) { { beer: true, grapefruit: true } }
 
-      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,grapefruit' => ['are mutually exclusive']
+        )
       end
     end
 
-    context 'when params keys come as strings' do
-      let(:params) { { 'beer' => true, 'grapefruit' => true } }
+    context 'when custom message is specified' do
+      let(:path) { '/custom-message' }
+      let(:params) { { beer: true, wine: true } }
 
-      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' => ['you should not mix beer and wine']
+        )
       end
     end
 
     context 'when no mutually exclusive params are present' do
+      let(:path) { '/' }
       let(:params) { { beer: true, somethingelse: true } }
 
-      it 'params' 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 mutually exclusive params are nested inside required hash' do
+      let(:path) { '/nested-hash' }
+      let(:params) { { item: { beer: true, wine: 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]' => ['are mutually exclusive']
+        )
+      end
+    end
+
+    context 'when mutually exclusive params are nested inside optional hash' do
+      let(:path) { '/nested-optional-hash' }
+
+      context 'when params are passed' do
+        let(:params) { { item: { beer: true, wine: 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]' => ['are mutually exclusive']
+          )
+        end
+      end
+
+      context 'when params are empty' do
+        let(:params) { {} }
+
+        it 'does not return a validation error' do
+          validate
+          expect(last_response.status).to eq 201
+        end
+      end
+    end
+
+    context 'when mutually exclusive params are nested inside array' do
+      let(:path) { '/nested-array' }
+      let(:params) { { items: [{ beer: true, wine: true }, { wine: true, grapefruit: 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][beer],items[0][wine]' => ['are mutually exclusive'],
+          'items[1][wine],items[1][grapefruit]' => ['are mutually exclusive']
+        )
+      end
+    end
+
+    context 'when mutually exclusive params are deeply nested' do
+      let(:path) { '/deeply-nested-array' }
+      let(:params) { { items: [{ nested_items: [{ beer: true, wine: 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]' => ['are mutually exclusive']
+        )
       end
     end
   end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Grape::Validations::SameAsValidator do
+  module ValidationsSpec
+    module SameAsValidatorSpec
+      class API < Grape::API
+        params do
+          requires :password
+          requires :password_confirmation, same_as: :password
+        end
+        post do
+        end
+
+        params do
+          requires :password
+          requires :password_confirmation, same_as: { value: :password, message: 'not match' }
+        end
+        post '/custom-message' do
+        end
+      end
+    end
+  end
+
+  def app
+    ValidationsSpec::SameAsValidatorSpec::API
+  end
+
+  describe '/' do
+    context 'is the same' do
+      it do
+        post '/', password: '987654', password_confirmation: '987654'
+        expect(last_response.status).to eq(201)
+        expect(last_response.body).to eq('')
+      end
+    end
+
+    context 'is not the same' do
+      it do
+        post '/', password: '123456', password_confirmation: 'whatever'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('password_confirmation is not the same as password')
+      end
+    end
+  end
+
+  describe '/custom-message' do
+    context 'is the same' do
+      it do
+        post '/custom-message', password: '987654', password_confirmation: '987654'
+        expect(last_response.status).to eq(201)
+        expect(last_response.body).to eq('')
+      end
+    end
+
+    context 'is not the same' do
+      it do
+        post '/custom-message', password: '123456', password_confirmation: 'whatever'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('password_confirmation not match')
+      end
+    end
+  end
+end

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