grape 1.2.4 → 1.2.5

data/spec/grape/validations/params_scope_spec.rb

@@ -165,6 +165,19 @@ describe Grape::Validations::ParamsScope do
 
       expect(last_response.status).to eq(200)
     end
+
+    it do
+      subject.params do
+        requires :foo, as: :baz, type: Hash do
+          requires :bar, as: :qux
+        end
+      end
+      subject.get('/nested-renaming') { declared(params).to_json }
+      get '/nested-renaming', foo: { bar: 'any' }
+
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('{"baz":{"qux":"any"}}')
+    end
   end
 
   context 'array without coerce type explicitly given' do

data/spec/grape/validations/single_attribute_iterator_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Grape::Validations::SingleAttributeIterator do
+  describe '#each' do
+    subject(:iterator) { described_class.new(validator, scope, params) }
+    let(:scope) { Grape::Validations::ParamsScope.new(api: Class.new(Grape::API)) }
+    let(:validator) { double(attrs: %i[first second third]) }
+
+    context 'when params is a hash' do
+      let(:params) do
+        { first: 'string', second: 'string' }
+      end
+
+      it 'yields params and every single attribute from the list' do
+        expect { |b| iterator.each(&b) }
+          .to yield_successive_args([params, :first], [params, :second], [params, :third])
+      end
+    end
+
+    context 'when params is an array' do
+      let(:params) do
+        [{ first: 'string1', second: 'string1' }, { first: 'string2', second: 'string2' }]
+      end
+
+      it 'yields every single attribute from the list for each of the array elements' do
+        expect { |b| iterator.each(&b) }.to yield_successive_args(
+          [params[0], :first], [params[0], :second], [params[0], :third],
+          [params[1], :first], [params[1], :second], [params[1], :third]
+        )
+      end
+    end
+  end
+end

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

@@ -2,58 +2,166 @@ require 'spec_helper'
 
 describe Grape::Validations::AllOrNoneOfValidator do
   describe '#validate!' do
-    let(:scope) do
-      Struct.new(:opts) do
-        def params(arg)
-          arg
-        end
+    subject(:validate) { post path, params }
+
+    module ValidationsSpec
+      module AllOrNoneOfValidatorSpec
+        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, :wine, type: Boolean
+            all_or_none_of :beer, :wine
+          end
+          post do
+          end
+
+          params do
+            optional :beer, :wine, :other, type: Boolean
+            all_or_none_of :beer, :wine
+          end
+          post 'mixed-params' do
+          end
+
+          params do
+            optional :beer, :wine, type: Boolean
+            all_or_none_of :beer, :wine, message: 'choose all or none'
+          end
+          post '/custom-message' do
+          end
+
+          params do
+            requires :item, type: Hash do
+              optional :beer, :wine, type: Boolean
+              all_or_none_of :beer, :wine
+            end
+          end
+          post '/nested-hash' do
+          end
+
+          params do
+            requires :items, type: Array do
+              optional :beer, :wine, type: Boolean
+              all_or_none_of :beer, :wine
+            end
+          end
+          post '/nested-array' do
+          end
 
-        def required?; end
+          params do
+            requires :items, type: Array do
+              requires :nested_items, type: Array do
+                optional :beer, :wine, type: Boolean
+                all_or_none_of :beer, :wine
+              end
+            end
+          end
+          post '/deeply-nested-array' do
+          end
+        end
       end
     end
-    let(:all_or_none_params) { %i[beer wine grapefruit] }
-    let(:validator) { described_class.new(all_or_none_params, {}, false, scope.new) }
+
+    def app
+      ValidationsSpec::AllOrNoneOfValidatorSpec::API
+    end
 
     context 'when all restricted params are present' do
-      let(:params) { { beer: true, wine: true, grapefruit: true } }
+      let(:path) { '/' }
+      let(:params) { { beer: true, wine: true } }
 
-      it 'does not raise a validation exception' 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
 
       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, other: true } }
 
-        it 'does not raise a validation exception' do
-          expect(validator.validate!(mixed_params)).to eql mixed_params
+        it 'does not return a validation error' do
+          validate
+          expect(last_response.status).to eq 201
         end
       end
     end
 
-    context 'when none of the restricted params is selected' do
+    context 'when a subset of restricted params are present' do
+      let(:path) { '/' }
+      let(:params) { { beer: true } }
+
+      it 'returns a validation error' do
+        validate
+        expect(last_response.status).to eq 400
+        expect(JSON.parse(last_response.body)).to eq(
+          'beer,wine' => ['provide all or none of parameters']
+        )
+      end
+    end
+
+    context 'when custom message is specified' do
+      let(:path) { '/custom-message' }
+      let(:params) { { beer: true } }
+
+      it 'returns a validation error' do
+        validate
+        expect(last_response.status).to eq 400
+        expect(JSON.parse(last_response.body)).to eq(
+          'beer,wine' => ['choose all or none']
+        )
+      end
+    end
+
+    context 'when no restricted params are present' do
+      let(:path) { '/' }
       let(:params) { { somethingelse: true } }
 
-      it 'does not raise a validation exception' 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 only a subset of restricted params are present' do
-      let(:params) { { beer: true, grapefruit: true } }
+    context 'when restricted params are nested inside required hash' do
+      let(:path) { '/nested-hash' }
+      let(:params) { { item: { beer: true } } }
 
-      it 'raises a validation exception' do
-        expect do
-          validator.validate! params
-        end.to raise_error(Grape::Exceptions::Validation)
+      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]' => ['provide all or none of parameters']
+        )
       end
-      context 'mixed with other params' do
-        let(:mixed_params) { params.merge!(other: true, andanother: true) }
+    end
 
-        it 'raise a validation exception' do
-          expect do
-            validator.validate! params
-          end.to raise_error(Grape::Exceptions::Validation)
-        end
+    context 'when mutually exclusive params are nested inside array' do
+      let(:path) { '/nested-array' }
+      let(:params) { { items: [{ beer: true, wine: 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[1][beer],items[1][wine]' => ['provide all or none of parameters']
+        )
+      end
+    end
+
+    context 'when mutually exclusive params are deeply nested' do
+      let(:path) { '/deeply-nested-array' }
+      let(:params) { { items: [{ nested_items: [{ beer: 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]' => [
+            'provide all or none of parameters'
+          ]
+        )
       end
     end
   end

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

@@ -2,65 +2,209 @@ require 'spec_helper'
 
 describe Grape::Validations::AtLeastOneOfValidator do
   describe '#validate!' do
-    let(:scope) do
-      Struct.new(:opts) do
-        def params(arg)
-          arg
-        end
+    subject(:validate) { post path, params }
+
+    module ValidationsSpec
+      module AtLeastOneOfValidatorSpec
+        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, :wine, :grapefruit
+            at_least_one_of :beer, :wine, :grapefruit
+          end
+          post do
+          end
+
+          params do
+            optional :beer, :wine, :grapefruit, :other
+            at_least_one_of :beer, :wine, :grapefruit
+          end
+          post 'mixed-params' do
+          end
+
+          params do
+            optional :beer, :wine, :grapefruit
+            at_least_one_of :beer, :wine, :grapefruit, message: 'you should choose something'
+          end
+          post '/custom-message' do
+          end
+
+          params do
+            requires :item, type: Hash do
+              optional :beer, :wine, :grapefruit
+              at_least_one_of :beer, :wine, :grapefruit, message: 'fail'
+            end
+          end
+          post '/nested-hash' do
+          end
 
-        def required?; end
+          params do
+            requires :items, type: Array do
+              optional :beer, :wine, :grapefruit
+              at_least_one_of :beer, :wine, :grapefruit, message: 'fail'
+            end
+          end
+          post '/nested-array' do
+          end
+
+          params do
+            requires :items, type: Array do
+              requires :nested_items, type: Array do
+                optional :beer, :wine, :grapefruit
+                at_least_one_of :beer, :wine, :grapefruit, message: 'fail'
+              end
+            end
+          end
+          post '/deeply-nested-array' do
+          end
+        end
       end
     end
-    let(:at_least_one_of_params) { %i[beer wine grapefruit] }
-    let(:validator) { described_class.new(at_least_one_of_params, {}, false, scope.new) }
+
+    def app
+      ValidationsSpec::AtLeastOneOfValidatorSpec::API
+    end
 
     context 'when all restricted params are present' do
+      let(:path) { '/' }
       let(:params) { { beer: true, wine: true, grapefruit: true } }
 
-      it 'does not raise a validation exception' 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
 
       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 'does not raise a validation exception' do
-          expect(validator.validate!(mixed_params)).to eql mixed_params
+        it 'does not return a validation error' do
+          validate
+          expect(last_response.status).to eq 201
         end
       end
     end
 
     context 'when a subset of restricted params are present' do
+      let(:path) { '/' }
       let(:params) { { beer: true, grapefruit: true } }
 
-      it 'does not raise a validation exception' 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 params keys come as strings' do
-      let(:params) { { 'beer' => true, 'grapefruit' => true } }
+    context 'when none of the restricted params is selected' do
+      let(:path) { '/' }
+      let(:params) { { other: true } }
+
+      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, at least one parameter must be provided']
+        )
+      end
+
+      context 'when custom message is specified' do
+        let(:path) { '/custom-message' }
 
-      it 'does not raise a validation exception' do
-        expect(validator.validate!(params)).to eql params
+        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 something']
+          )
+        end
       end
     end
 
-    context 'when none of the restricted params is selected' do
-      let(:params) { { somethingelse: true } }
+    context 'when exactly one of the restricted params is selected' do
+      let(:path) { '/' }
+      let(:params) { { beer: true } }
 
-      it 'raises a validation exception' do
-        expect do
-          validator.validate! params
-        end.to raise_error(Grape::Exceptions::Validation)
+      it 'does not return a validation error' do
+        validate
+        expect(last_response.status).to eq 201
       end
     end
 
-    context 'when exactly one of the restricted params is selected' do
-      let(:params) { { beer: true, somethingelse: true } }
+    context 'when restricted params are nested inside hash' do
+      let(:path) { '/nested-hash' }
+
+      context 'when at least one of them is present' do
+        let(:params) { { item: { beer: true, wine: true } } }
+
+        it 'does not return a validation error' do
+          validate
+          expect(last_response.status).to eq 201
+        end
+      end
 
-      it 'does not raise a validation exception' do
-        expect(validator.validate!(params)).to eql params
+      context 'when none of them are present' do
+        let(:params) { { item: { other: 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]' => ['fail']
+          )
+        end
+      end
+    end
+
+    context 'when restricted params are nested inside array' do
+      let(:path) { '/nested-array' }
+
+      context 'when at least one of them is present' do
+        let(:params) { { items: [{ beer: true, wine: true }, { grapefruit: true }] } }
+
+        it 'does not return a validation error' do
+          validate
+          expect(last_response.status).to eq 201
+        end
+      end
+
+      context 'when none of them are present' do
+        let(:params) { { items: [{ beer: true, other: true }, { other: 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[1][beer],items[1][wine],items[1][grapefruit]' => ['fail']
+          )
+        end
+      end
+    end
+
+    context 'when restricted params are deeply nested' do
+      let(:path) { '/deeply-nested-array' }
+
+      context 'when at least one of them is present' do
+        let(:params) { { items: [{ nested_items: [{ wine: true }] }] } }
+
+        it 'does not return a validation error' do
+          validate
+          expect(last_response.status).to eq 201
+        end
+      end
+
+      context 'when none of them are present' do
+        let(:params) { { items: [{ nested_items: [{ other: 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],items[0][nested_items][0][grapefruit]' => ['fail']
+          )
+        end
       end
     end
   end