grape 1.2.4 → 1.2.5

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

@@ -20,10 +20,13 @@ describe Grape::Validations::CoerceValidator do
 
     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 +43,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
@@ -576,7 +580,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')
 
@@ -592,7 +596,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

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

@@ -2,73 +2,237 @@ require 'spec_helper'
 
 describe Grape::Validations::ExactlyOneOfValidator do
   describe '#validate!' do
-    let(:scope) do
-      Struct.new(:opts) do
-        def params(arg)
-          arg
-        end
+    subject(:validate) { post path, params }
+
+    module ValidationsSpec
+      module ExactlyOneOfValidatorSpec
+        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
+            exactly_one_of :beer, :wine, :grapefruit
+          end
+          post do
+          end
+
+          params do
+            optional :beer
+            optional :wine
+            optional :grapefruit
+            optional :other
+            exactly_one_of :beer, :wine, :grapefruit
+          end
+          post 'mixed-params' do
+          end
+
+          params do
+            optional :beer
+            optional :wine
+            optional :grapefruit
+            exactly_one_of :beer, :wine, :grapefruit, message: 'you should choose one'
+          end
+          post '/custom-message' do
+          end
 
-        def required?; end
+          params do
+            requires :item, type: Hash do
+              optional :beer
+              optional :wine
+              optional :grapefruit
+              exactly_one_of :beer, :wine, :grapefruit
+            end
+          end
+          post '/nested-hash' do
+          end
+
+          params do
+            optional :item, type: Hash do
+              optional :beer
+              optional :wine
+              optional :grapefruit
+              exactly_one_of :beer, :wine, :grapefruit
+            end
+          end
+          post '/nested-optional-hash' do
+          end
+
+          params do
+            requires :items, type: Array do
+              optional :beer
+              optional :wine
+              optional :grapefruit
+              exactly_one_of :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
+                exactly_one_of :beer, :wine, :grapefruit
+              end
+            end
+          end
+          post '/deeply-nested-array' do
+          end
+        end
       end
     end
-    let(:exactly_one_of_params) { %i[beer wine grapefruit] }
-    let(:validator) { described_class.new(exactly_one_of_params, {}, false, scope.new) }
 
-    context 'when all restricted params are present' do
+    def app
+      ValidationsSpec::ExactlyOneOfValidatorSpec::API
+    end
+
+    context 'when all 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 missing, exactly one parameter must be provided']
+        )
       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 missing, exactly one parameter must be provided']
+          )
         end
       end
     end
 
-    context 'when a subset of restricted params are present' do
+    context 'when a subset of 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,wine,grapefruit' => ['are missing, exactly one parameter must be provided']
+        )
       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,grapefruit' => ['you should choose one']
+        )
       end
     end
 
-    context 'when none of the restricted params is selected' do
+    context 'when exacly one param is present' do
+      let(:path) { '/' }
+      let(:params) { { beer: true, somethingelse: true } }
+
+      it 'does not return a validation error' do
+        validate
+        expect(last_response.status).to eq 201
+      end
+    end
+
+    context 'when none of the params are present' do
+      let(:path) { '/' }
       let(:params) { { somethingelse: 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 missing, exactly one parameter must be provided']
+        )
       end
     end
 
-    context 'when exactly one of the restricted params is selected' do
-      let(:params) { { beer: true, somethingelse: true } }
+    context 'when 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],item[grapefruit]' => ['are missing, exactly one parameter must be provided']
+        )
+      end
+    end
+
+    context 'when 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],item[grapefruit]' => ['are missing, exactly one parameter must be provided']
+          )
+        end
+      end
+
+      context 'when params are empty' do
+        let(:params) { { other: true } }
+
+        it 'does not return a validation error' do
+          validate
+          expect(last_response.status).to eq 201
+        end
+      end
+    end
+
+    context 'when 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],items[0][grapefruit]' => [
+            'are missing, exactly one parameter must be provided'
+          ],
+          'items[1][beer],items[1][wine],items[1][grapefruit]' => [
+            'are missing, exactly one parameter must be provided'
+          ]
+        )
+      end
+    end
+
+    context 'when params are deeply nested' do
+      let(:path) { '/deeply-nested-array' }
+      let(:params) { { items: [{ nested_items: [{ beer: true, wine: true }] }] } }
 
-      it 'does not raise a validation exception' do
-        expect(validator.validate!(params)).to eql params
+      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]' => [
+            'are missing, exactly one parameter must be provided'
+          ]
+        )
       end
     end
   end

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

@@ -2,61 +2,218 @@ 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