grape 1.1.0 → 1.2.5

data/spec/grape/request_spec.rb

@@ -62,6 +62,30 @@ module Grape
       end
     end
 
+    describe 'when the param_builder is set to Hashie' do
+      before do
+        Grape.configure do |config|
+          config.param_builder = Grape::Extensions::Hashie::Mash::ParamBuilder
+        end
+      end
+
+      after do
+        Grape.config.reset
+      end
+
+      subject(:request_params) { Grape::Request.new(env, opts).params }
+
+      context 'when the API does not include a specific param builder' do
+        let(:opts) { {} }
+        it { is_expected.to be_a(Hashie::Mash) }
+      end
+
+      context 'when the API includes a specific param builder' do
+        let(:opts) { { build_params_with: Grape::Extensions::Hash::ParamBuilder } }
+        it { is_expected.to be_a(Hash) }
+      end
+    end
+
     describe '#headers' do
       let(:options) do
         default_options.merge(request_headers)

data/spec/grape/validations/multiple_attributes_iterator_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Grape::Validations::MultipleAttributesIterator 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 the whole params hash without the list of attrs' do
+        expect { |b| iterator.each(&b) }.to yield_with_args(params)
+      end
+    end
+
+    context 'when params is an array' do
+      let(:params) do
+        [{ first: 'string1', second: 'string1' }, { first: 'string2', second: 'string2' }]
+      end
+
+      it 'yields each element of the array without the list of attrs' do
+        expect { |b| iterator.each(&b) }.to yield_successive_args(params[0], params[1])
+      end
+    end
+  end
+end

data/spec/grape/validations/params_scope_spec.rb

@@ -121,14 +121,14 @@ describe Grape::Validations::ParamsScope do
     end
   end
 
-  context 'param alias' do
+  context 'param renaming' do
     it do
       subject.params do
         requires :foo, as: :bar
         optional :super, as: :hiper
       end
-      subject.get('/alias') { "#{declared(params)['bar']}-#{declared(params)['hiper']}" }
-      get '/alias', foo: 'any', super: 'any2'
+      subject.get('/renaming') { "#{declared(params)['bar']}-#{declared(params)['hiper']}" }
+      get '/renaming', foo: 'any', super: 'any2'
 
       expect(last_response.status).to eq(200)
       expect(last_response.body).to eq('any-any2')
@@ -138,8 +138,8 @@ describe Grape::Validations::ParamsScope do
       subject.params do
         requires :foo, as: :bar, type: String, coerce_with: ->(c) { c.strip }
       end
-      subject.get('/alias-coerced') { "#{params['bar']}-#{params['foo']}" }
-      get '/alias-coerced', foo: ' there we go '
+      subject.get('/renaming-coerced') { "#{params['bar']}-#{params['foo']}" }
+      get '/renaming-coerced', foo: ' there we go '
 
       expect(last_response.status).to eq(200)
       expect(last_response.body).to eq('there we go-')
@@ -149,12 +149,35 @@ describe Grape::Validations::ParamsScope do
       subject.params do
         requires :foo, as: :bar, allow_blank: false
       end
-      subject.get('/alias-not-blank') {}
-      get '/alias-not-blank', foo: ''
+      subject.get('/renaming-not-blank') {}
+      get '/renaming-not-blank', foo: ''
 
       expect(last_response.status).to eq(400)
       expect(last_response.body).to eq('foo is empty')
     end
+
+    it do
+      subject.params do
+        requires :foo, as: :bar, allow_blank: false
+      end
+      subject.get('/renaming-not-blank-with-value') {}
+      get '/renaming-not-blank-with-value', foo: 'any'
+
+      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
@@ -479,7 +502,50 @@ describe Grape::Validations::ParamsScope do
       end.to_not raise_error
     end
 
-    it 'allows aliasing of dependent parameters' do
+    it 'does not raise an error if when using nested given' do
+      expect do
+        subject.params do
+          optional :a, type: Hash do
+            requires :b
+          end
+          given :a do
+            requires :c
+            given :c do
+              requires :d
+            end
+          end
+        end
+      end.to_not raise_error
+    end
+
+    it 'allows nested dependent parameters' do
+      subject.params do
+        optional :a
+        given a: ->(val) { val == 'a' } do
+          optional :b
+          given b: ->(val) { val == 'b' } do
+            optional :c
+            given c: ->(val) { val == 'c' } do
+              requires :d
+            end
+          end
+        end
+      end
+      subject.get('/') { declared(params).to_json }
+
+      get '/'
+      expect(last_response.status).to eq 200
+
+      get '/', a: 'a', b: 'b', c: 'c'
+      expect(last_response.status).to eq 400
+      expect(last_response.body).to eq 'd is missing'
+
+      get '/', a: 'a', b: 'b', c: 'c', d: 'd'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq({ a: 'a', b: 'b', c: 'c', d: 'd' }.to_json)
+    end
+
+    it 'allows renaming of dependent parameters' do
       subject.params do
         optional :a
         given :a do
@@ -497,6 +563,34 @@ describe Grape::Validations::ParamsScope do
       expect(body.keys).to_not include('b')
     end
 
+    it 'allows renaming of dependent on parameter' do
+      subject.params do
+        optional :a, as: :b
+        given b: ->(val) { val == 'x' } do
+          requires :c
+        end
+      end
+      subject.get('/') { declared(params) }
+
+      get '/', a: 'x'
+      expect(last_response.status).to eq 400
+      expect(last_response.body).to eq 'c is missing'
+
+      get '/', a: 'y'
+      expect(last_response.status).to eq 200
+    end
+
+    it 'raises an error if the dependent parameter is not the renamed one' do
+      expect do
+        subject.params do
+          optional :a, as: :b
+          given :a do
+            requires :c
+          end
+        end
+      end.to raise_error(Grape::Exceptions::UnknownParameter)
+    end
+
     it 'does not validate nested requires when given is false' do
       subject.params do
         requires :a, type: String, allow_blank: false, values: %w[x y z]
@@ -592,7 +686,53 @@ describe Grape::Validations::ParamsScope do
     end
   end
 
+  context 'default value in given block' do
+    before do
+      subject.params do
+        optional :a, values: %w[a b]
+        given a: ->(val) { val == 'a' } do
+          optional :b, default: 'default'
+        end
+      end
+      subject.get('/') { params.to_json }
+    end
+
+    context 'when dependency meets' do
+      it 'sets default value for dependent parameter' do
+        get '/', a: 'a'
+        expect(last_response.body).to eq({ a: 'a', b: 'default' }.to_json)
+      end
+    end
+
+    context 'when dependency does not meet' do
+      it 'does not set default value for dependent parameter' do
+        get '/', a: 'b'
+        expect(last_response.body).to eq({ a: 'b' }.to_json)
+      end
+    end
+  end
+
   context 'when validations are dependent on a parameter within an array param' do
+    before do
+      subject.params do
+        requires :foos, type: Array do
+          optional :foo
+          given :foo do
+            requires :bar
+          end
+        end
+      end
+      subject.get('/test') { 'ok' }
+    end
+
+    it 'should pass none Hash params' do
+      get '/test', foos: ['']
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('ok')
+    end
+  end
+
+  context 'when validations are dependent on a parameter within an array param within #declared(params).to_json' do
     before do
       subject.params do
         requires :foos, type: Array do
@@ -948,4 +1088,40 @@ describe Grape::Validations::ParamsScope do
       end
     end
   end
+
+  context 'with exactly_one_of validation for optional parameters within an Hash param' do
+    before do
+      subject.params do
+        optional :memo, type: Hash do
+          optional :text, type: String
+          optional :custom_body, type: Hash, coerce_with: JSON
+          exactly_one_of :text, :custom_body
+        end
+      end
+      subject.get('test')
+    end
+
+    context 'when correct data is provided' do
+      it 'returns a successful response' do
+        get 'test', memo: {}
+        expect(last_response.status).to eq(200)
+
+        get 'test', memo: { text: 'HOGEHOGE' }
+        expect(last_response.status).to eq(200)
+
+        get 'test', memo: { custom_body: '{ "xxx": "yyy" }' }
+        expect(last_response.status).to eq(200)
+      end
+    end
+
+    context 'when invalid data is provided' do
+      it 'returns a failure response' do
+        get 'test', memo: { text: 'HOGEHOGE', custom_body: '{ "xxx": "yyy" }' }
+        expect(last_response.status).to eq(400)
+
+        get 'test', memo: '{ "custom_body": "HOGE" }'
+        expect(last_response.status).to eq(400)
+      end
+    end
+  end
 end

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