grape 1.0.0 → 1.6.0

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
@@ -74,7 +76,7 @@ describe Grape::Validations::ParamsScope do
   end
 
   context 'setting description' do
-    [:desc, :description].each do |description_type|
+    %i[desc description].each do |description_type|
       it "allows setting #{description_type}" do
         subject.params do
           requires :int, type: Integer, description_type => 'My very nice integer'
@@ -96,6 +98,7 @@ describe Grape::Validations::ParamsScope do
 
         def self.parse(value)
           raise if value == 'invalid'
+
           new(value)
         end
 
@@ -121,21 +124,102 @@ describe Grape::Validations::ParamsScope do
     end
   end
 
+  context 'param renaming' do
+    it do
+      subject.params do
+        requires :foo, as: :bar
+        optional :super, as: :hiper
+      end
+      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')
+    end
+
+    it do
+      subject.params do
+        requires :foo, as: :bar, type: String, coerce_with: ->(c) { c.strip }
+      end
+      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')
+    end
+
+    it do
+      subject.params do
+        requires :foo, as: :bar, allow_blank: false
+      end
+      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
+
+    it 'renaming can be defined before default' do
+      subject.params do
+        optional :foo, as: :bar, default: 'before'
+      end
+      subject.get('/rename-before-default') { declared(params)[:bar] }
+      get '/rename-before-default'
+
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('before')
+    end
+
+    it 'renaming can be defined after default' do
+      subject.params do
+        optional :foo, default: 'after', as: :bar
+      end
+      subject.get('/rename-after-default') { declared(params)[:bar] }
+      get '/rename-after-default'
+
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('after')
+    end
+  end
+
   context 'array without coerce type explicitly given' do
     it 'sets the type based on first element' do
       subject.params do
-        requires :periods, type: Array, values: -> { %w(day month) }
+        requires :periods, type: Array, values: -> { %w[day month] }
       end
       subject.get('/required') { 'required works' }
 
-      get '/required', periods: %w(day month)
+      get '/required', periods: %w[day month]
       expect(last_response.status).to eq(200)
       expect(last_response.body).to eq('required works')
     end
 
     it 'fails to call API without Array type' do
       subject.params do
-        requires :periods, type: Array, values: -> { %w(day month) }
+        requires :periods, type: Array, values: -> { %w[day month] }
       end
       subject.get('/required') { 'required works' }
 
@@ -303,6 +387,18 @@ describe Grape::Validations::ParamsScope do
       get '/optional_type_array'
     end
 
+    it 'handles missing optional Array type' do
+      subject.params do
+        optional :a, type: Array do
+          requires :b
+        end
+      end
+      subject.get('/test') { declared(params).to_json }
+      get '/test'
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('{"a":[]}')
+    end
+
     it 'errors with an unsupported type' do
       expect do
         subject.params do
@@ -418,6 +514,185 @@ describe Grape::Validations::ParamsScope do
       end.to raise_error(Grape::Exceptions::UnknownParameter)
     end
 
+    it 'does not raise an error if the dependent parameter is a Hash' do
+      expect do
+        subject.params do
+          optional :a, type: Hash do
+            requires :b
+          end
+          given :a do
+            requires :c
+          end
+        end
+      end.to_not raise_error
+    end
+
+    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
+          requires :b, as: :c
+        end
+      end
+
+      subject.get('/multiple') { declared(params).to_json }
+
+      get '/multiple', a: 'a', b: 'b'
+
+      body = JSON.parse(last_response.body)
+
+      expect(body.keys).to include('c')
+      expect(body.keys).to_not include('b')
+    end
+
+    it 'allows renaming of dependent on parameter' do
+      subject.params do
+        optional :a, as: :b
+        given a: ->(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 'does not raise 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.not_to raise_error
+    end
+
+    it 'raises an error if the dependent parameter is the renamed one' do
+      expect do
+        subject.params do
+          optional :a, as: :b
+          given :b 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]
+        given a: ->(val) { val == 'x' } do
+          requires :inner1, type: Hash, allow_blank: false do
+            requires :foo, type: Integer, allow_blank: false
+          end
+        end
+        given a: ->(val) { val == 'y' } do
+          requires :inner2, type: Hash, allow_blank: false do
+            requires :bar, type: Integer, allow_blank: false
+            requires :baz, type: Array, allow_blank: false do
+              requires :baz_category, type: String, allow_blank: false
+            end
+          end
+        end
+        given a: ->(val) { val == 'z' } do
+          requires :inner3, type: Array, allow_blank: false do
+            requires :bar, type: Integer, allow_blank: false
+            requires :baz, type: Array, allow_blank: false do
+              requires :baz_category, type: String, allow_blank: false
+            end
+          end
+        end
+      end
+      subject.get('/varying') { declared(params).to_json }
+
+      get '/varying', a: 'x', inner1: { foo: 1 }
+      expect(last_response.status).to eq(200)
+
+      get '/varying', a: 'y', inner2: { bar: 2, baz: [{ baz_category: 'barstools' }] }
+      expect(last_response.status).to eq(200)
+
+      get '/varying', a: 'y', inner2: { bar: 2, baz: [{ unrelated: 'yep' }] }
+      expect(last_response.status).to eq(400)
+
+      get '/varying', a: 'z', inner3: [{ bar: 3, baz: [{ baz_category: 'barstools' }] }]
+      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
 
@@ -473,7 +748,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
@@ -498,8 +819,8 @@ describe Grape::Validations::ParamsScope do
 
   context 'when validations are dependent on a parameter with specific value' do
     # build test cases from all combinations of declarations and options
-    a_decls = %i(optional requires)
-    a_options = [{}, { values: %w(x y z) }]
+    a_decls = %i[optional requires]
+    a_options = [{}, { values: %w[x y z] }]
     b_options = [{}, { type: String }, { allow_blank: false }, { type: String, allow_blank: false }]
     combinations = a_decls.product(a_options, b_options)
     combinations.each_with_index do |combination, i|
@@ -829,4 +1150,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

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Grape::Validations::Types::PrimitiveCoercer do
+  let(:strict) { false }
+
+  subject { described_class.new(type, strict) }
+
+  describe '#call' do
+    context 'BigDecimal' do
+      let(:type) { BigDecimal }
+
+      it 'coerces to BigDecimal' do
+        expect(subject.call(5)).to eq(BigDecimal('5'))
+      end
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'Boolean' do
+      let(:type) { Grape::API::Boolean }
+
+      [true, 'true', 1].each do |val|
+        it "coerces '#{val}' to true" do
+          expect(subject.call(val)).to eq(true)
+        end
+      end
+
+      [false, 'false', 0].each do |val|
+        it "coerces '#{val}' to false" do
+          expect(subject.call(val)).to eq(false)
+        end
+      end
+
+      it 'returns an error when the given value cannot be coerced' do
+        expect(subject.call(123)).to be_instance_of(Grape::Validations::Types::InvalidValue)
+      end
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'DateTime' do
+      let(:type) { DateTime }
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'Float' do
+      let(:type) { Float }
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'Integer' do
+      let(:type) { Integer }
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'Numeric' do
+      let(:type) { Numeric }
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'Time' do
+      let(:type) { Time }
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'String' do
+      let(:type) { String }
+
+      it 'coerces to String' do
+        expect(subject.call(10)).to eq('10')
+      end
+
+      it 'does not coerce an empty string to nil' do
+        expect(subject.call('')).to eq('')
+      end
+    end
+
+    context 'Symbol' do
+      let(:type) { Symbol }
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'the strict mode' do
+      let(:strict) { true }
+
+      context 'Boolean' do
+        let(:type) { Grape::API::Boolean }
+
+        it 'returns an error when the given value is not Boolean' do
+          expect(subject.call(1)).to be_instance_of(Grape::Validations::Types::InvalidValue)
+        end
+
+        it 'returns a value as it is when the given value is Boolean' do
+          expect(subject.call(true)).to eq(true)
+        end
+      end
+
+      context 'BigDecimal' do
+        let(:type) { BigDecimal }
+
+        it 'returns an error when the given value is not BigDecimal' do
+          expect(subject.call(1)).to be_instance_of(Grape::Validations::Types::InvalidValue)
+        end
+
+        it 'returns a value as it is when the given value is BigDecimal' do
+          expect(subject.call(BigDecimal('0'))).to eq(BigDecimal('0'))
+        end
+      end
+    end
+  end
+end

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

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