grape 1.1.0 → 1.7.1

data/spec/grape/validations/params_scope_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Grape::Validations::ParamsScope do
   subject do
@@ -9,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: Virtus::Attribute::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
@@ -96,6 +16,7 @@ describe Grape::Validations::ParamsScope do
 
         def self.parse(value)
           raise if value == 'invalid'
+
           new(value)
         end
 
@@ -121,14 +42,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,23 +59,68 @@ 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-')
+      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('/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
+
+    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
@@ -244,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
 
@@ -252,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
@@ -290,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
@@ -298,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
@@ -358,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
@@ -366,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
 
@@ -476,10 +442,53 @@ 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
+      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.not_to 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 aliasing of dependent parameters' do
+    it 'allows renaming of dependent parameters' do
       subject.params do
         optional :a
         given :a do
@@ -494,7 +503,46 @@ 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 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
@@ -537,6 +585,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
 
@@ -590,9 +664,366 @@ 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
+    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 'passes 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
@@ -761,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
@@ -773,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
@@ -823,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
@@ -948,4 +1381,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