grape 1.5.2 → 1.7.0

data/spec/grape/validations/params_scope_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Grape::Validations::ParamsScope do
   subject do
     Class.new(Grape::API)
@@ -11,86 +9,6 @@ describe Grape::Validations::ParamsScope do
     subject
   end
 
-  context 'setting a default' do
-    let(:documentation) { subject.routes.first.params }
-
-    context 'when the default value is truthy' do
-      before do
-        subject.params do
-          optional :int, type: Integer, default: 42
-        end
-        subject.get
-      end
-
-      it 'adds documentation about the default value' do
-        expect(documentation).to have_key('int')
-        expect(documentation['int']).to have_key(:default)
-        expect(documentation['int'][:default]).to eq(42)
-      end
-    end
-
-    context 'when the default value is false' do
-      before do
-        subject.params do
-          optional :bool, type: Grape::API::Boolean, default: false
-        end
-        subject.get
-      end
-
-      it 'adds documentation about the default value' do
-        expect(documentation).to have_key('bool')
-        expect(documentation['bool']).to have_key(:default)
-        expect(documentation['bool'][:default]).to eq(false)
-      end
-    end
-
-    context 'when the default value is nil' do
-      before do
-        subject.params do
-          optional :object, type: Object, default: nil
-        end
-        subject.get
-      end
-
-      it 'adds documentation about the default value' do
-        expect(documentation).to have_key('object')
-        expect(documentation['object']).to have_key(:default)
-        expect(documentation['object'][:default]).to eq(nil)
-      end
-    end
-  end
-
-  context 'without a default' do
-    before do
-      subject.params do
-        optional :object, type: Object
-      end
-      subject.get
-    end
-
-    it 'does not add documentation for the default value' do
-      documentation = subject.routes.first.params
-      expect(documentation).to have_key('object')
-      expect(documentation['object']).not_to have_key(:default)
-    end
-  end
-
-  context 'setting description' do
-    %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'
-        end
-        subject.get '/single' do
-          'int works'
-        end
-        get '/single', int: 420
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('int works')
-      end
-    end
-  end
-
   context 'when using custom types' do
     module ParamsScopeSpec
       class CustomType
@@ -98,6 +16,7 @@ describe Grape::Validations::ParamsScope do
 
         def self.parse(value)
           raise if value == 'invalid'
+
           new(value)
         end
 
@@ -144,7 +63,7 @@ describe Grape::Validations::ParamsScope do
       get '/renaming-coerced', foo: ' there we go '
 
       expect(last_response.status).to eq(200)
-      expect(last_response.body).to eq('there we go-')
+      expect(last_response.body).to eq('-there we go')
     end
 
     it do
@@ -180,6 +99,28 @@ describe Grape::Validations::ParamsScope do
       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
@@ -269,7 +210,7 @@ describe Grape::Validations::ParamsScope do
         it 'does not raise an exception' do
           expect do
             subject.params { optional :numbers, type: Array[Integer], values: 0..2, default: 0..2 }
-          end.to_not raise_error
+          end.not_to raise_error
         end
       end
 
@@ -277,7 +218,7 @@ describe Grape::Validations::ParamsScope do
         it 'does not raise an exception' do
           expect do
             subject.params { optional :numbers, type: Array[Integer], values: [0, 1, 2], default: [1, 0] }
-          end.to_not raise_error
+          end.not_to raise_error
         end
       end
     end
@@ -315,7 +256,7 @@ describe Grape::Validations::ParamsScope do
             requires :b
           end
         end
-      end.to raise_error Grape::Exceptions::MissingGroupTypeError
+      end.to raise_error Grape::Exceptions::MissingGroupType
 
       expect do
         subject.params do
@@ -323,7 +264,7 @@ describe Grape::Validations::ParamsScope do
             requires :b
           end
         end
-      end.to raise_error Grape::Exceptions::MissingGroupTypeError
+      end.to raise_error Grape::Exceptions::MissingGroupType
     end
 
     it 'allows Hash as type' do
@@ -383,7 +324,7 @@ describe Grape::Validations::ParamsScope do
             requires :b
           end
         end
-      end.to raise_error Grape::Exceptions::UnsupportedGroupTypeError
+      end.to raise_error Grape::Exceptions::UnsupportedGroupType
 
       expect do
         subject.params do
@@ -391,7 +332,7 @@ describe Grape::Validations::ParamsScope do
             requires :b
           end
         end
-      end.to raise_error Grape::Exceptions::UnsupportedGroupTypeError
+      end.to raise_error Grape::Exceptions::UnsupportedGroupType
     end
   end
 
@@ -501,7 +442,7 @@ describe Grape::Validations::ParamsScope do
             requires :c
           end
         end
-      end.to_not raise_error
+      end.not_to raise_error
     end
 
     it 'does not raise an error if when using nested given' do
@@ -517,7 +458,7 @@ describe Grape::Validations::ParamsScope do
             end
           end
         end
-      end.to_not raise_error
+      end.not_to raise_error
     end
 
     it 'allows nested dependent parameters' do
@@ -562,13 +503,13 @@ describe Grape::Validations::ParamsScope do
       body = JSON.parse(last_response.body)
 
       expect(body.keys).to include('c')
-      expect(body.keys).to_not include('b')
+      expect(body.keys).not_to include('b')
     end
 
     it 'allows renaming of dependent on parameter' do
       subject.params do
         optional :a, as: :b
-        given b: ->(val) { val == 'x' } do
+        given a: ->(val) { val == 'x' } do
           requires :c
         end
       end
@@ -582,7 +523,7 @@ describe Grape::Validations::ParamsScope do
       expect(last_response.status).to eq 200
     end
 
-    it 'raises an error if the dependent parameter is not the renamed one' do
+    it 'does not raise if the dependent parameter is not the renamed one' do
       expect do
         subject.params do
           optional :a, as: :b
@@ -590,6 +531,17 @@ describe Grape::Validations::ParamsScope 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
 
@@ -712,6 +664,317 @@ describe Grape::Validations::ParamsScope do
       get '/nested', bar: { a: true, c: { b: 'yes' } }
       expect(JSON.parse(last_response.body)).to eq('bar' => { 'a' => 'true', 'c' => { 'b' => 'yes' } })
     end
+
+    context 'when the dependent parameter is not present #declared(params)' do
+      context 'lateral parameter' do
+        before do
+          [true, false].each do |evaluate_given|
+            subject.params do
+              optional :a
+              given :a do
+                optional :b
+              end
+            end
+            subject.get("/evaluate_given_#{evaluate_given}") { declared(params, evaluate_given: evaluate_given).to_json }
+          end
+        end
+
+        it 'evaluate_given_false' do
+          get '/evaluate_given_false', b: 'b'
+          expect(JSON.parse(last_response.body)).to eq('a' => nil, 'b' => 'b')
+        end
+
+        it 'evaluate_given_true' do
+          get '/evaluate_given_true', b: 'b'
+          expect(JSON.parse(last_response.body)).to eq('a' => nil)
+        end
+      end
+
+      context 'lateral hash parameter' do
+        before do
+          [true, false].each do |evaluate_given|
+            subject.params do
+              optional :a, values: %w[x y]
+              given a: ->(a) { a == 'x' } do
+                optional :b, type: Hash do
+                  optional :c
+                end
+                optional :e
+              end
+              given a: ->(a) { a == 'y' } do
+                optional :b, type: Hash do
+                  optional :d
+                end
+                optional :f
+              end
+            end
+            subject.get("/evaluate_given_#{evaluate_given}") { declared(params, evaluate_given: evaluate_given).to_json }
+          end
+        end
+
+        it 'evaluate_given_false' do
+          get '/evaluate_given_false', a: 'x'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'x', 'b' => { 'd' => nil }, 'e' => nil, 'f' => nil)
+
+          get '/evaluate_given_false', a: 'y'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'y', 'b' => { 'd' => nil }, 'e' => nil, 'f' => nil)
+        end
+
+        it 'evaluate_given_true' do
+          get '/evaluate_given_true', a: 'x'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'x', 'b' => { 'c' => nil }, 'e' => nil)
+
+          get '/evaluate_given_true', a: 'y'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'y', 'b' => { 'd' => nil }, 'f' => nil)
+        end
+      end
+
+      context 'lateral parameter within lateral hash parameter' do
+        before do
+          [true, false].each do |evaluate_given|
+            subject.params do
+              optional :a, values: %w[x y]
+              given a: ->(a) { a == 'x' } do
+                optional :b, type: Hash do
+                  optional :c
+                  given :c do
+                    optional :g
+                    optional :e, type: Hash do
+                      optional :h
+                    end
+                  end
+                end
+              end
+              given a: ->(a) { a == 'y' } do
+                optional :b, type: Hash do
+                  optional :d
+                  given :d do
+                    optional :f
+                    optional :e, type: Hash do
+                      optional :i
+                    end
+                  end
+                end
+              end
+            end
+            subject.get("/evaluate_given_#{evaluate_given}") { declared(params, evaluate_given: evaluate_given).to_json }
+          end
+        end
+
+        it 'evaluate_given_false' do
+          get '/evaluate_given_false', a: 'x'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'x', 'b' => { 'd' => nil, 'f' => nil, 'e' => { 'i' => nil } })
+
+          get '/evaluate_given_false', a: 'x', b: { c: 'c' }
+          expect(JSON.parse(last_response.body)).to eq('a' => 'x', 'b' => { 'd' => nil, 'f' => nil, 'e' => { 'i' => nil } })
+
+          get '/evaluate_given_false', a: 'y'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'y', 'b' => { 'd' => nil, 'f' => nil, 'e' => { 'i' => nil } })
+
+          get '/evaluate_given_false', a: 'y', b: { d: 'd' }
+          expect(JSON.parse(last_response.body)).to eq('a' => 'y', 'b' => { 'd' => 'd', 'f' => nil, 'e' => { 'i' => nil } })
+        end
+
+        it 'evaluate_given_true' do
+          get '/evaluate_given_true', a: 'x'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'x', 'b' => { 'c' => nil })
+
+          get '/evaluate_given_true', a: 'x', b: { c: 'c' }
+          expect(JSON.parse(last_response.body)).to eq('a' => 'x', 'b' => { 'c' => 'c', 'g' => nil, 'e' => { 'h' => nil } })
+
+          get '/evaluate_given_true', a: 'y'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'y', 'b' => { 'd' => nil })
+
+          get '/evaluate_given_true', a: 'y', b: { d: 'd' }
+          expect(JSON.parse(last_response.body)).to eq('a' => 'y', 'b' => { 'd' => 'd', 'f' => nil, 'e' => { 'i' => nil } })
+        end
+      end
+
+      context 'lateral parameter within an array param' do
+        before do
+          [true, false].each do |evaluate_given|
+            subject.params do
+              optional :array, type: Array do
+                optional :a
+                given :a do
+                  optional :b
+                end
+              end
+            end
+            subject.post("/evaluate_given_#{evaluate_given}") do
+              declared(params, evaluate_given: evaluate_given).to_json
+            end
+          end
+        end
+
+        it 'evaluate_given_false' do
+          post '/evaluate_given_false', { array: [{ b: 'b' }, { a: 'a', b: 'b' }] }.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('array' => [{ 'a' => nil, 'b' => 'b' }, { 'a' => 'a', 'b' => 'b' }])
+        end
+
+        it 'evaluate_given_true' do
+          post '/evaluate_given_true', { array: [{ b: 'b' }, { a: 'a', b: 'b' }] }.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('array' => [{ 'a' => nil }, { 'a' => 'a', 'b' => 'b' }])
+        end
+      end
+
+      context 'nested given parameter' do
+        before do
+          [true, false].each do |evaluate_given|
+            subject.params do
+              optional :a
+              optional :c
+              given :a do
+                given :c do
+                  optional :b
+                end
+              end
+            end
+            subject.post("/evaluate_given_#{evaluate_given}") do
+              declared(params, evaluate_given: evaluate_given).to_json
+            end
+          end
+        end
+
+        it 'evaluate_given_false' do
+          post '/evaluate_given_false', { a: 'a', b: 'b' }.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'a', 'b' => 'b', 'c' => nil)
+
+          post '/evaluate_given_false', { c: 'c', b: 'b' }.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('a' => nil, 'b' => 'b', 'c' => 'c')
+
+          post '/evaluate_given_false', { a: 'a', c: 'c', b: 'b' }.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'a', 'b' => 'b', 'c' => 'c')
+        end
+
+        it 'evaluate_given_true' do
+          post '/evaluate_given_true', { a: 'a', b: 'b' }.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'a', 'c' => nil)
+
+          post '/evaluate_given_true', { c: 'c', b: 'b' }.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('a' => nil, 'c' => 'c')
+
+          post '/evaluate_given_true', { a: 'a', c: 'c', b: 'b' }.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('a' => 'a', 'b' => 'b', 'c' => 'c')
+        end
+      end
+
+      context 'nested given parameter within an array param' do
+        before do
+          [true, false].each do |evaluate_given|
+            subject.params do
+              optional :array, type: Array do
+                optional :a
+                optional :c
+                given :a do
+                  given :c do
+                    optional :b
+                  end
+                end
+              end
+            end
+            subject.post("/evaluate_given_#{evaluate_given}") do
+              declared(params, evaluate_given: evaluate_given).to_json
+            end
+          end
+        end
+
+        let :evaluate_given_params do
+          {
+            array: [
+              { a: 'a', b: 'b' },
+              { c: 'c', b: 'b' },
+              { a: 'a', c: 'c', b: 'b' }
+            ]
+          }
+        end
+
+        it 'evaluate_given_false' do
+          post '/evaluate_given_false', evaluate_given_params.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('array' => [{ 'a' => 'a', 'b' => 'b', 'c' => nil }, { 'a' => nil, 'b' => 'b', 'c' => 'c' }, { 'a' => 'a', 'b' => 'b', 'c' => 'c' }])
+        end
+
+        it 'evaluate_given_true' do
+          post '/evaluate_given_true', evaluate_given_params.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq('array' => [{ 'a' => 'a', 'c' => nil }, { 'a' => nil, 'c' => 'c' }, { 'a' => 'a', 'b' => 'b', 'c' => 'c' }])
+        end
+      end
+
+      context 'nested given parameter within a nested given parameter within an array param' do
+        before do
+          [true, false].each do |evaluate_given|
+            subject.params do
+              optional :array, type: Array do
+                optional :a
+                optional :c
+                given :a do
+                  given :c do
+                    optional :array, type: Array do
+                      optional :a
+                      optional :c
+                      given :a do
+                        given :c do
+                          optional :b
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+            subject.post("/evaluate_given_#{evaluate_given}") do
+              declared(params, evaluate_given: evaluate_given).to_json
+            end
+          end
+        end
+
+        let :evaluate_given_params do
+          {
+            array: [{
+              a: 'a',
+              c: 'c',
+              array: [
+                { a: 'a', b: 'b' },
+                { c: 'c', b: 'b' },
+                { a: 'a', c: 'c', b: 'b' }
+              ]
+            }]
+          }
+        end
+
+        it 'evaluate_given_false' do
+          expected_response_hash = {
+            'array' => [{
+              'a' => 'a',
+              'c' => 'c',
+              'array' => [
+                { 'a' => 'a', 'b' => 'b', 'c' => nil },
+                { 'a' => nil, 'c' => 'c', 'b' => 'b' },
+                { 'a' => 'a', 'c' => 'c', 'b' => 'b' }
+              ]
+            }]
+          }
+          post '/evaluate_given_false', evaluate_given_params.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq(expected_response_hash)
+        end
+
+        it 'evaluate_given_true' do
+          expected_response_hash = {
+            'array' => [{
+              'a' => 'a',
+              'c' => 'c',
+              'array' => [
+                { 'a' => 'a', 'c' => nil },
+                { 'a' => nil, 'c' => 'c' },
+                { 'a' => 'a', 'b' => 'b', 'c' => 'c' }
+              ]
+            }]
+          }
+          post '/evaluate_given_true', evaluate_given_params.to_json, 'CONTENT_TYPE' => 'application/json'
+          expect(JSON.parse(last_response.body)).to eq(expected_response_hash)
+        end
+      end
+    end
   end
 
   context 'default value in given block' do
@@ -753,7 +1016,7 @@ describe Grape::Validations::ParamsScope do
       subject.get('/test') { 'ok' }
     end
 
-    it 'should pass none Hash params' do
+    it 'passes none Hash params' do
       get '/test', foos: ['']
       expect(last_response.status).to eq(200)
       expect(last_response.body).to eq('ok')
@@ -929,6 +1192,7 @@ describe Grape::Validations::ParamsScope do
         expect(last_response.body).to eq('one is missing, two is missing, three is missing')
       end
     end
+
     context 'when fail_fast is defined it stops the validation' do
       it 'of other params' do
         subject.params do
@@ -941,6 +1205,7 @@ describe Grape::Validations::ParamsScope do
         expect(last_response.status).to eq(400)
         expect(last_response.body).to eq('one is missing')
       end
+
       it 'for a single param' do
         subject.params do
           requires :one, allow_blank: false, regexp: /[0-9]+/, fail_fast: true
@@ -991,7 +1256,7 @@ describe Grape::Validations::ParamsScope do
         end
 
         it 'prioritizes parameter validation over group validation' do
-          expect(last_response.body).to_not include('address is empty')
+          expect(last_response.body).not_to include('address is empty')
         end
       end
     end

data/spec/grape/validations/single_attribute_iterator_spec.rb

@@ -1,10 +1,9 @@
 # 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]) }
 
@@ -49,7 +48,7 @@ describe Grape::Validations::SingleAttributeIterator do
         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],
+            [params[1], :first, false, false], [params[1], :second, false, false]
           )
         end
       end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Grape::Validations::Types::ArrayCoercer do
   subject { described_class.new(type) }