grape 1.1.0 → 1.5.3

data/spec/grape/validations/attributes_iterator_spec.rb

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

data/spec/grape/validations/instance_behaivour_spec.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe 'Validator with instance variables' do
   let(:validator_type) do
     Class.new(Grape::Validations::Base) do
       def validate_param!(_attr_name, _params)
-        if @instance_variable
-          raise Grape::Exceptions::Validation, params: ['params'],
-                                               message: 'This should never happen'
+        if instance_variable_defined?(:@instance_variable) && @instance_variable
+          raise Grape::Exceptions::Validation.new(params: ['params'],
+                                                  message: 'This should never happen')
         end
         @instance_variable = true
       end

data/spec/grape/validations/multiple_attributes_iterator_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+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 and the skipped flag without the list of attrs' do
+        expect { |b| iterator.each(&b) }.to yield_with_args(params, false)
+      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], false], [params[1], false])
+      end
+    end
+
+    context 'when params is empty optional placeholder' do
+      let(:params) do
+        [Grape::DSL::Parameters::EmptyOptionalValue, { 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([Grape::DSL::Parameters::EmptyOptionalValue, true], [params[1], false])
+      end
+    end
+  end
+end

data/spec/grape/validations/params_scope_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::ParamsScope do
@@ -30,7 +32,7 @@ describe Grape::Validations::ParamsScope do
     context 'when the default value is false' do
       before do
         subject.params do
-          optional :bool, type: Virtus::Attribute::Boolean, default: false
+          optional :bool, type: Grape::API::Boolean, default: false
         end
         subject.get
       end
@@ -121,14 +123,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 +140,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 +151,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 +504,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 +565,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]
@@ -537,6 +633,32 @@ describe Grape::Validations::ParamsScope do
       expect(last_response.status).to eq(200)
     end
 
+    it 'detect unmet nested dependency' do
+      subject.params do
+        requires :a, type: String, allow_blank: false, values: %w[x y z]
+        given a: ->(val) { val == 'z' } do
+          requires :inner3, type: Array, allow_blank: false do
+            requires :bar, type: String, allow_blank: false
+            given bar: ->(val) { val == 'b' } do
+              requires :baz, type: Array do
+                optional :baz_category, type: String
+              end
+            end
+            given bar: ->(val) { val == 'c' } do
+              requires :baz, type: Array do
+                requires :baz_category, type: String
+              end
+            end
+          end
+        end
+      end
+      subject.get('/nested-dependency') { declared(params).to_json }
+
+      get '/nested-dependency', a: 'z', inner3: [{ bar: 'c', baz: [{ unrelated: 'nope' }] }]
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq 'inner3[0][baz][0][baz_category] is missing'
+    end
+
     it 'includes the parameter within #declared(params)' do
       get '/test', a: true, b: true
 
@@ -592,7 +714,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 +1116,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,58 @@
+# frozen_string_literal: true
+
+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]) }
+
+    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, false, false], [params, :second, false, false])
+      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, false, false], [params[0], :second, false, false],
+          [params[1], :first, false, false], [params[1], :second, false, false]
+        )
+      end
+
+      context 'empty values' do
+        let(:params) { [{}, '', 10] }
+
+        it 'marks params with empty values' do
+          expect { |b| iterator.each(&b) }.to yield_successive_args(
+            [params[0], :first, true, false], [params[0], :second, true, false],
+            [params[1], :first, true, false], [params[1], :second, true, false],
+            [params[2], :first, false, false], [params[2], :second, false, false]
+          )
+        end
+      end
+
+      context 'when missing optional value' do
+        let(:params) { [Grape::DSL::Parameters::EmptyOptionalValue, 10] }
+
+        it 'marks params with skipped values' do
+          expect { |b| iterator.each(&b) }.to yield_successive_args(
+            [params[0], :first, false, true], [params[0], :second, false, true],
+            [params[1], :first, false, false], [params[1], :second, false, false],
+          )
+        end
+      end
+    end
+  end
+end

data/spec/grape/validations/types/array_coercer_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Grape::Validations::Types::ArrayCoercer do
+  subject { described_class.new(type) }
+
+  describe '#call' do
+    context 'an array of primitives' do
+      let(:type) { Array[String] }
+
+      it 'coerces elements in the array' do
+        expect(subject.call([10, 20])).to eq(%w[10 20])
+      end
+    end
+
+    context 'an array of arrays' do
+      let(:type) { Array[Array[Integer]] }
+
+      it 'coerces elements in the nested array' do
+        expect(subject.call([%w[10 20]])).to eq([[10, 20]])
+        expect(subject.call([['10'], ['20']])).to eq([[10], [20]])
+      end
+    end
+
+    context 'an array of sets' do
+      let(:type) { Array[Set[Integer]] }
+
+      it 'coerces elements in the nested set' do
+        expect(subject.call([%w[10 20]])).to eq([Set[10, 20]])
+        expect(subject.call([['10'], ['20']])).to eq([Set[10], Set[20]])
+      end
+    end
+  end
+end