grape 0.9.0 → 0.10.0

data/spec/grape/validations/{regexp_spec.rb → validators/regexp_spec.rb}

@@ -10,7 +10,6 @@ describe Grape::Validations::RegexpValidator do
           requires :name, regexp: /^[a-z]+$/
         end
         get do
-
         end
       end
     end
@@ -22,7 +21,7 @@ describe Grape::Validations::RegexpValidator do
 
   context 'invalid input' do
     it 'refuses inapppopriate' do
-      get '/', name: "invalid name"
+      get '/', name: 'invalid name'
       expect(last_response.status).to eq(400)
     end
 
@@ -33,8 +32,7 @@ describe Grape::Validations::RegexpValidator do
   end
 
   it 'accepts valid input' do
-    get '/', name: "bob"
+    get '/', name: 'bob'
     expect(last_response.status).to eq(200)
   end
-
 end

data/spec/grape/validations/{values_spec.rb → validators/values_spec.rb}

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Grape::Validations::ValuesValidator do
-
   class ValuesModel
     DEFAULT_VALUES = ['valid-type1', 'valid-type2', 'valid-type3']
     class << self
@@ -44,15 +43,36 @@ describe Grape::Validations::ValuesValidator do
         end
 
         params do
-          requires :type, type: Integer, desc: "An integer", values: [10, 11], default: 10
+          optional :type, values: ValuesModel.values, default: -> { ValuesModel.values.sample }
+        end
+        get '/default_lambda' do
+          { type: params[:type] }
+        end
+
+        params do
+          optional :type, values: -> { ValuesModel.values }, default: -> { ValuesModel.values.sample }
+        end
+        get '/default_and_values_lambda' do
+          { type: params[:type] }
+        end
+
+        params do
+          requires :type, type: Integer, desc: 'An integer', values: [10, 11], default: 10
         end
         get '/values/coercion' do
           { type: params[:type] }
         end
 
+        params do
+          requires :type, type: Array[Integer], desc: 'An integer', values: [10, 11], default: 10
+        end
+        get '/values/array_coercion' do
+          { type: params[:type] }
+        end
+
         params do
           optional :optional do
-            requires :type, values: ["a", "b"]
+            requires :type, values: %w(a b)
           end
         end
         get '/optional_with_required_values'
@@ -65,22 +85,22 @@ describe Grape::Validations::ValuesValidator do
   end
 
   it 'allows a valid value for a parameter' do
-    get("/", type: 'valid-type1')
+    get('/', type: 'valid-type1')
     expect(last_response.status).to eq 200
-    expect(last_response.body).to eq({ type: "valid-type1" }.to_json)
+    expect(last_response.body).to eq({ type: 'valid-type1' }.to_json)
   end
 
   it 'does not allow an invalid value for a parameter' do
-    get("/", type: 'invalid-type')
+    get('/', type: 'invalid-type')
     expect(last_response.status).to eq 400
-    expect(last_response.body).to eq({ error: "type does not have a valid value" }.to_json)
+    expect(last_response.body).to eq({ error: 'type does not have a valid value' }.to_json)
   end
 
   context 'nil value for a parameter' do
     it 'does not allow for root params scope' do
-      get("/", type: nil)
+      get('/', type: nil)
       expect(last_response.status).to eq 400
-      expect(last_response.body).to eq({ error: "type does not have a valid value" }.to_json)
+      expect(last_response.body).to eq({ error: 'type does not have a valid value' }.to_json)
     end
 
     it 'allows for a required param in child scope' do
@@ -90,15 +110,15 @@ describe Grape::Validations::ValuesValidator do
   end
 
   it 'allows a valid default value' do
-    get("/default/valid")
+    get('/default/valid')
     expect(last_response.status).to eq 200
-    expect(last_response.body).to eq({ type: "valid-type2" }.to_json)
+    expect(last_response.body).to eq({ type: 'valid-type2' }.to_json)
   end
 
   it 'allows a proc for values' do
     get('/lambda', type: 'valid-type1')
     expect(last_response.status).to eq 200
-    expect(last_response.body).to eq({ type: "valid-type1" }.to_json)
+    expect(last_response.body).to eq({ type: 'valid-type1' }.to_json)
   end
 
   it 'does not validate updated values without proc' do
@@ -106,7 +126,7 @@ describe Grape::Validations::ValuesValidator do
 
     get('/', type: 'valid-type4')
     expect(last_response.status).to eq 400
-    expect(last_response.body).to eq({ error: "type does not have a valid value" }.to_json)
+    expect(last_response.body).to eq({ error: 'type does not have a valid value' }.to_json)
   end
 
   it 'validates against values in a proc' do
@@ -114,39 +134,91 @@ describe Grape::Validations::ValuesValidator do
 
     get('/lambda', type: 'valid-type4')
     expect(last_response.status).to eq 200
-    expect(last_response.body).to eq({ type: "valid-type4" }.to_json)
+    expect(last_response.body).to eq({ type: 'valid-type4' }.to_json)
   end
 
   it 'does not allow an invalid value for a parameter using lambda' do
-    get("/lambda", type: 'invalid-type')
+    get('/lambda', type: 'invalid-type')
     expect(last_response.status).to eq 400
-    expect(last_response.body).to eq({ error: "type does not have a valid value" }.to_json)
+    expect(last_response.body).to eq({ error: 'type does not have a valid value' }.to_json)
+  end
+
+  it 'validates default value from proc' do
+    get('/default_lambda')
+    expect(last_response.status).to eq 200
+  end
+
+  it 'validates default value from proc against values in a proc' do
+    get('/default_and_values_lambda')
+    expect(last_response.status).to eq 200
+  end
+
+  it 'raises IncompatibleOptionValues on an invalid default value from proc' do
+    subject = Class.new(Grape::API)
+    expect do
+      subject.params { optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], default: ValuesModel.values.sample + '_invalid' }
+    end.to raise_error Grape::Exceptions::IncompatibleOptionValues
   end
 
   it 'raises IncompatibleOptionValues on an invalid default value' do
     subject = Class.new(Grape::API)
-    expect {
+    expect do
       subject.params { optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], default: 'invalid-type' }
-    }.to raise_error Grape::Exceptions::IncompatibleOptionValues
+    end.to raise_error Grape::Exceptions::IncompatibleOptionValues
   end
 
   it 'raises IncompatibleOptionValues when type is incompatible with values array' do
     subject = Class.new(Grape::API)
-    expect {
+    expect do
       subject.params { optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], type: Symbol }
-    }.to raise_error Grape::Exceptions::IncompatibleOptionValues
+    end.to raise_error Grape::Exceptions::IncompatibleOptionValues
   end
 
   it 'allows values to be a kind of the coerced type not just an instance of it' do
-    get("/values/coercion", type: 10)
+    get('/values/coercion', type: 10)
     expect(last_response.status).to eq 200
     expect(last_response.body).to eq({ type: 10 }.to_json)
   end
 
+  it 'allows values to be a kind of the coerced type in an array' do
+    get('/values/array_coercion', type: [10])
+    expect(last_response.status).to eq 200
+    expect(last_response.body).to eq({ type: [10] }.to_json)
+  end
+
   it 'raises IncompatibleOptionValues when values contains a value that is not a kind of the type' do
     subject = Class.new(Grape::API)
-    expect {
+    expect do
       subject.params { requires :type, values: [10.5, 11], type: Integer }
-    }.to raise_error Grape::Exceptions::IncompatibleOptionValues
+    end.to raise_error Grape::Exceptions::IncompatibleOptionValues
+  end
+
+  context 'with a lambda values' do
+    subject do
+      Class.new(Grape::API) do
+        params do
+          optional :type, type: String, values: -> { [SecureRandom.uuid] }, default: -> { SecureRandom.uuid }
+        end
+        get '/random_values'
+      end
+    end
+
+    def app
+      subject
+    end
+
+    before do
+      expect(SecureRandom).to receive(:uuid).and_return('foo').once
+    end
+
+    it 'only evaluates values dynamically with each request' do
+      get '/random_values', type: 'foo'
+      expect(last_response.status).to eq 200
+    end
+
+    it 'chooses default' do
+      get '/random_values'
+      expect(last_response.status).to eq 200
+    end
   end
 end

data/spec/grape/validations_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Grape::Validations do
-
   subject { Class.new(Grape::API) }
 
   def app
@@ -44,18 +43,17 @@ describe Grape::Validations do
         subject.params do
           optional :some_param
         end
-        expect(subject.settings[:declared_params]).to eq([:some_param])
+        expect(subject.route_setting(:declared_params)).to eq([:some_param])
       end
     end
 
     context 'required' do
       before do
         subject.params do
-          requires :key
-        end
-        subject.get '/required' do
-          'required works'
+          requires :key, type: String
         end
+        subject.get('/required') { 'required works' }
+        subject.put('/required') { { key: params[:key] }.to_json }
       end
 
       it 'errors when param not present' do
@@ -74,7 +72,13 @@ describe Grape::Validations do
         subject.params do
           requires :some_param
         end
-        expect(subject.settings[:declared_params]).to eq([:some_param])
+        expect(subject.route_setting(:declared_params)).to eq([:some_param])
+      end
+
+      it 'works when required field is present but nil' do
+        put '/required', { key: nil }.to_json, 'CONTENT_TYPE' => 'application/json'
+        expect(last_response.status).to eq(200)
+        expect(JSON.parse(last_response.body)).to eq('key' => nil)
       end
     end
 
@@ -97,7 +101,7 @@ describe Grape::Validations do
 
       it 'adds entity documentation to declared params' do
         define_requires_all
-        expect(subject.settings[:declared_params]).to eq([:required_field, :optional_field])
+        expect(subject.route_setting(:declared_params)).to eq([:required_field, :optional_field])
       end
 
       it 'errors when required_field is not present' do
@@ -132,7 +136,7 @@ describe Grape::Validations do
 
       it 'adds entity documentation to declared params' do
         define_requires_none
-        expect(subject.settings[:declared_params]).to eq([:required_field, :optional_field])
+        expect(subject.route_setting(:declared_params)).to eq([:required_field, :optional_field])
       end
 
       it 'errors when required_field is not present' do
@@ -162,7 +166,7 @@ describe Grape::Validations do
 
         it 'adds only the entity documentation to declared params, nothing more' do
           define_requires_all
-          expect(subject.settings[:declared_params]).to eq([:required_field, :optional_field])
+          expect(subject.route_setting(:declared_params)).to eq([:required_field, :optional_field])
         end
       end
 
@@ -190,9 +194,8 @@ describe Grape::Validations do
             requires :key
           end
         end
-        subject.get '/required' do
-          'required works'
-        end
+        subject.get('/required') { 'required works' }
+        subject.put('/required') { { items: params[:items] }.to_json }
       end
 
       it 'errors when param not present' do
@@ -201,8 +204,8 @@ describe Grape::Validations do
         expect(last_response.body).to eq('items is missing')
       end
 
-      it "errors when param is not an Array" do
-        get '/required', items: "hello"
+      it 'errors when param is not an Array' do
+        get '/required', items: 'hello'
         expect(last_response.status).to eq(400)
         expect(last_response.body).to eq('items is invalid, items[key] is missing')
 
@@ -217,14 +220,10 @@ describe Grape::Validations do
         expect(last_response.body).to eq('required works')
       end
 
-      it "doesn't allow any key in the options hash other than type" do
-        expect {
-          subject.params do
-            requires(:items, desc: 'Foo') do
-              requires :key
-            end
-          end
-        }.to raise_error ArgumentError
+      it "doesn't throw a missing param when param is present but empty" do
+        put '/required', { items: [] }.to_json, 'CONTENT_TYPE' => 'application/json'
+        expect(last_response.status).to eq(200)
+        expect(JSON.parse(last_response.body)).to eq('items' => [])
       end
 
       it 'adds to declared parameters' do
@@ -233,7 +232,7 @@ describe Grape::Validations do
             requires :key
           end
         end
-        expect(subject.settings[:declared_params]).to eq([items: [:key]])
+        expect(subject.route_setting(:declared_params)).to eq([items: [:key]])
       end
     end
 
@@ -255,8 +254,8 @@ describe Grape::Validations do
         expect(last_response.body).to eq('items is missing, items[key] is missing')
       end
 
-      it "errors when param is not a Hash" do
-        get '/required', items: "hello"
+      it 'errors when param is not a Hash' do
+        get '/required', items: 'hello'
         expect(last_response.status).to eq(400)
         expect(last_response.body).to eq('items is invalid, items[key] is missing')
 
@@ -271,23 +270,13 @@ describe Grape::Validations do
         expect(last_response.body).to eq('required works')
       end
 
-      it "doesn't allow any key in the options hash other than type" do
-        expect {
-          subject.params do
-            requires(:items, desc: 'Foo') do
-              requires :key
-            end
-          end
-        }.to raise_error ArgumentError
-      end
-
       it 'adds to declared parameters' do
         subject.params do
           requires :items do
             requires :key
           end
         end
-        expect(subject.settings[:declared_params]).to eq([items: [:key]])
+        expect(subject.route_setting(:declared_params)).to eq([items: [:key]])
       end
     end
 
@@ -321,7 +310,85 @@ describe Grape::Validations do
             requires :key
           end
         end
-        expect(subject.settings[:declared_params]).to eq([items: [:key]])
+        expect(subject.route_setting(:declared_params)).to eq([items: [:key]])
+      end
+    end
+
+    context 'group params with nested params which has a type' do
+      let(:invalid_items){ { items: '' } }
+
+      before do
+        subject.params do
+          optional :items do
+            optional :key1, type: String
+            optional :key2, type: String
+          end
+        end
+        subject.post '/group_with_nested' do
+          'group with nested works'
+        end
+      end
+
+      it 'errors when group param is invalid'do
+        post '/group_with_nested', items: invalid_items
+        expect(last_response.status).to eq(400)
+      end
+    end
+
+    context 'custom validator for a Hash' do
+      module DateRangeValidations
+        class DateRangeValidator < Grape::Validations::Base
+          def validate_param!(attr_name, params)
+            unless params[attr_name][:from] <= params[attr_name][:to]
+              fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: "'from' must be lower or equal to 'to'"
+            end
+          end
+        end
+      end
+
+      before do
+        subject.params do
+          optional :date_range, date_range: true, type: Hash do
+            requires :from, type: Integer
+            requires :to, type: Integer
+          end
+        end
+        subject.get('/optional') do
+          'optional works'
+        end
+        subject.params do
+          requires :date_range, date_range: true, type: Hash do
+            requires :from, type: Integer
+            requires :to, type: Integer
+          end
+        end
+        subject.get('/required') do
+          'required works'
+        end
+      end
+
+      context 'which is optional' do
+        it "doesn't throw an error if the validation passes" do
+          get '/optional', date_range: { from: 1, to: 2 }
+          expect(last_response.status).to eq(200)
+        end
+
+        it 'errors if the validation fails' do
+          get '/optional', date_range: { from: 2, to: 1 }
+          expect(last_response.status).to eq(400)
+        end
+      end
+
+      context 'which is required' do
+        it "doesn't throw an error if the validation passes" do
+          get '/required', date_range: { from: 1, to: 2 }
+          expect(last_response.status).to eq(200)
+        end
+
+        it 'errors if the validation fails' do
+          get '/required', date_range: { from: 2, to: 1 }
+          expect(last_response.status).to eq(400)
+        end
       end
     end
 
@@ -371,9 +438,9 @@ describe Grape::Validations do
         expect(last_response.body).to eq('children[parents] is missing')
       end
 
-      it "errors when param is not an Array" do
+      it 'errors when param is not an Array' do
         # NOTE: would be nicer if these just returned 'children is invalid'
-        get '/within_array', children: "hello"
+        get '/within_array', children: 'hello'
         expect(last_response.status).to eq(400)
         expect(last_response.body).to eq('children is invalid, children[name] is missing, children[parents] is missing, children[parents] is invalid, children[parents][name] is missing')
 
@@ -428,7 +495,7 @@ describe Grape::Validations do
       end
 
       it 'requires defaults to Array type' do
-        get '/req', planets: "Jupiter, Saturn"
+        get '/req', planets: 'Jupiter, Saturn'
         expect(last_response.status).to eq(400)
         expect(last_response.body).to eq('planets is invalid, planets[name] is missing')
 
@@ -444,26 +511,26 @@ describe Grape::Validations do
       end
 
       it 'optional defaults to Array type' do
-        get '/opt', name: "Jupiter", moons: "Europa, Ganymede"
+        get '/opt', name: 'Jupiter', moons: 'Europa, Ganymede'
         expect(last_response.status).to eq(400)
         expect(last_response.body).to eq('moons is invalid, moons[name] is missing')
 
-        get '/opt', name: "Jupiter", moons: { name: 'Ganymede' }
+        get '/opt', name: 'Jupiter', moons: { name: 'Ganymede' }
         expect(last_response.status).to eq(400)
         expect(last_response.body).to eq('moons is invalid')
 
-        get '/opt', name: "Jupiter", moons: [{ name: 'Io' }, { name: 'Callisto' }]
+        get '/opt', name: 'Jupiter', moons: [{ name: 'Io' }, { name: 'Callisto' }]
         expect(last_response.status).to eq(200)
 
-        put_with_json '/opt', name: "Venus"
+        put_with_json '/opt', name: 'Venus'
         expect(last_response.status).to eq(200)
 
-        put_with_json '/opt', name: "Mercury", moons: []
+        put_with_json '/opt', name: 'Mercury', moons: []
         expect(last_response.status).to eq(200)
       end
 
       it 'group defaults to Array type' do
-        get '/grp', stars: "Sun"
+        get '/grp', stars: 'Sun'
         expect(last_response.status).to eq(400)
         expect(last_response.body).to eq('stars is invalid, stars[name] is missing')
 
@@ -545,14 +612,14 @@ describe Grape::Validations do
         expect(last_response.body).to eq('optional group works')
       end
 
-      it "errors when group is present, but required param is not" do
+      it 'errors when group is present, but required param is not' do
         get '/optional_group', items: [{ not_key: 'foo' }]
         expect(last_response.status).to eq(400)
         expect(last_response.body).to eq('items[key] is missing')
       end
 
       it "errors when param is present but isn't an Array" do
-        get '/optional_group', items: "hello"
+        get '/optional_group', items: 'hello'
         expect(last_response.status).to eq(400)
         expect(last_response.body).to eq('items is invalid, items[key] is missing')
 
@@ -567,7 +634,7 @@ describe Grape::Validations do
             requires :key
           end
         end
-        expect(subject.settings[:declared_params]).to eq([items: [:key]])
+        expect(subject.route_setting(:declared_params)).to eq([items: [:key]])
       end
     end
 
@@ -631,7 +698,7 @@ describe Grape::Validations do
             requires(:required_subitems) { requires :value }
           end
         end
-        expect(subject.settings[:declared_params]).to eq([items: [:key, { optional_subitems: [:value] }, { required_subitems: [:value] }]])
+        expect(subject.route_setting(:declared_params)).to eq([items: [:key, { optional_subitems: [:value] }, { required_subitems: [:value] }]])
       end
     end
 
@@ -656,10 +723,10 @@ describe Grape::Validations do
 
     context 'custom validation' do
       module CustomValidations
-        class Customvalidator < Grape::Validations::Validator
+        class Customvalidator < Grape::Validations::Base
           def validate_param!(attr_name, params)
             unless params[attr_name] == 'im custom'
-              raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: "is not custom!"
+              fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: 'is not custom!'
             end
           end
         end
@@ -776,13 +843,13 @@ describe Grape::Validations do
             expect(last_response.body).to eq('custom is not custom!')
           end
 
-          specify 'the nested namesapce inherits the custom validator' do
+          specify 'the nested namespace inherits the custom validator' do
             get '/nested/nested/two', custom: 'im wrong, validate me'
             expect(last_response.status).to eq(400)
             expect(last_response.body).to eq('custom is not custom!')
           end
 
-          specify 'peer namesapces does not have the validator' do
+          specify 'peer namespaces does not have the validator' do
             get '/peer/one', custom: 'im not validated'
             expect(last_response.status).to eq(200)
             expect(last_response.body).to eq('no validation required')
@@ -805,10 +872,10 @@ describe Grape::Validations do
 
       context 'when using options on param' do
         module CustomValidations
-          class CustomvalidatorWithOptions < Grape::Validations::SingleOptionValidator
+          class CustomvalidatorWithOptions < Grape::Validations::Base
             def validate_param!(attr_name, params)
               unless params[attr_name] == @option[:text]
-                raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: @option[:error_message]
+                fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: @option[:error_message]
               end
             end
           end
@@ -816,7 +883,7 @@ describe Grape::Validations do
 
         before do
           subject.params do
-            optional :custom, customvalidator_with_options: { text: 'im custom with options', error_message: "is not custom with options!" }
+            optional :custom, customvalidator_with_options: { text: 'im custom with options', error_message: 'is not custom with options!' }
           end
           subject.get '/optional_custom' do
             'optional with custom works!'
@@ -877,16 +944,15 @@ describe Grape::Validations do
           subject.params do
             use :pagination
           end
-          expect(subject.settings[:declared_params]).to eq [:page, :per_page]
+          expect(subject.route_setting(:declared_params)).to eq [:page, :per_page]
         end
 
         it 'by #use with multiple params' do
           subject.params do
             use :pagination, :period
           end
-          expect(subject.settings[:declared_params]).to eq [:page, :per_page, :start_date, :end_date]
+          expect(subject.route_setting(:declared_params)).to eq [:page, :per_page, :start_date, :end_date]
         end
-
       end
 
       context 'with block' do
@@ -960,7 +1026,7 @@ describe Grape::Validations do
 
           get '/mutually_exclusive', beer: 'string', wine: 'anotherstring'
           expect(last_response.status).to eq(400)
-          expect(last_response.body).to eq "beer, wine are mutually exclusive"
+          expect(last_response.body).to eq 'beer, wine are mutually exclusive'
         end
       end
 
@@ -970,17 +1036,62 @@ describe Grape::Validations do
             optional :beer
             optional :wine
             mutually_exclusive :beer, :wine
-            optional :scotch
-            optional :aquavit
-            mutually_exclusive :scotch, :aquavit
+            optional :nested, type: Hash do
+              optional :scotch
+              optional :aquavit
+              mutually_exclusive :scotch, :aquavit
+            end
+            optional :nested2, type: Array do
+              optional :scotch2
+              optional :aquavit2
+              mutually_exclusive :scotch2, :aquavit2
+            end
           end
           subject.get '/mutually_exclusive' do
             'mutually_exclusive works!'
           end
 
-          get '/mutually_exclusive', beer: 'true', wine: 'true', scotch: 'true', aquavit: 'true'
+          get '/mutually_exclusive', beer: 'true', wine: 'true', nested: { scotch: 'true', aquavit: 'true' }, nested2: [{ scotch2: 'true' }, { scotch2: 'true', aquavit2: 'true' }]
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq 'beer, wine are mutually exclusive, scotch, aquavit are mutually exclusive, scotch2, aquavit2 are mutually exclusive'
+        end
+      end
+
+      context 'in a group' do
+        it 'works when only one from the set is present' do
+          subject.params do
+            group :drink, type: Hash do
+              optional :wine
+              optional :beer
+              optional :juice
+
+              mutually_exclusive :beer, :wine, :juice
+            end
+          end
+          subject.get '/mutually_exclusive_group' do
+            'mutually_exclusive_group works!'
+          end
+
+          get '/mutually_exclusive_group', drink: { beer: 'true' }
+          expect(last_response.status).to eq(200)
+        end
+
+        it 'errors when more than one from the set is present' do
+          subject.params do
+            group :drink, type: Hash do
+              optional :wine
+              optional :beer
+              optional :juice
+
+              mutually_exclusive :beer, :wine, :juice
+            end
+          end
+          subject.get '/mutually_exclusive_group' do
+            'mutually_exclusive_group works!'
+          end
+
+          get '/mutually_exclusive_group', drink: { beer: 'true', juice: 'true', wine: 'true' }
           expect(last_response.status).to eq(400)
-          expect(last_response.body).to eq "beer, wine are mutually exclusive, scotch, aquavit are mutually exclusive"
         end
       end
     end
@@ -1002,7 +1113,7 @@ describe Grape::Validations do
         it 'errors when none are present' do
           get '/exactly_one_of'
           expect(last_response.status).to eq(400)
-          expect(last_response.body).to eq "beer, wine, juice are missing, exactly one parameter must be provided"
+          expect(last_response.body).to eq 'beer, wine, juice are missing, exactly one parameter must be provided'
         end
 
         it 'succeeds when one is present' do
@@ -1014,7 +1125,47 @@ describe Grape::Validations do
         it 'errors when two or more are present' do
           get '/exactly_one_of', beer: 'string', wine: 'anotherstring'
           expect(last_response.status).to eq(400)
-          expect(last_response.body).to eq "beer, wine are mutually exclusive"
+          expect(last_response.body).to eq 'beer, wine are mutually exclusive'
+        end
+      end
+
+      context 'nested params' do
+        before :each do
+          subject.params do
+            requires :nested, type: Hash do
+              optional :beer_nested
+              optional :wine_nested
+              optional :juice_nested
+              exactly_one_of :beer_nested, :wine_nested, :juice_nested
+            end
+            optional :nested2, type: Array do
+              optional :beer_nested2
+              optional :wine_nested2
+              optional :juice_nested2
+              exactly_one_of :beer_nested2, :wine_nested2, :juice_nested2
+            end
+          end
+          subject.get '/exactly_one_of_nested' do
+            'exactly_one_of works!'
+          end
+        end
+
+        it 'errors when none are present' do
+          get '/exactly_one_of_nested'
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq 'nested is missing, beer_nested, wine_nested, juice_nested are missing, exactly one parameter must be provided'
+        end
+
+        it 'succeeds when one is present' do
+          get '/exactly_one_of_nested', nested: { beer_nested: 'string' }
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq 'exactly_one_of works!'
+        end
+
+        it 'errors when two or more are present' do
+          get '/exactly_one_of_nested', nested: { beer_nested: 'string' }, nested2: [{ beer_nested2: 'string', wine_nested2: 'anotherstring' }]
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq 'beer_nested2, wine_nested2 are mutually exclusive'
         end
       end
     end
@@ -1036,7 +1187,7 @@ describe Grape::Validations do
         it 'errors when none are present' do
           get '/at_least_one_of'
           expect(last_response.status).to eq(400)
-          expect(last_response.body).to eq "beer, wine, juice are missing, at least one parameter must be provided"
+          expect(last_response.body).to eq 'beer, wine, juice are missing, at least one parameter must be provided'
         end
 
         it 'does not error when one is present' do
@@ -1051,6 +1202,120 @@ describe Grape::Validations do
           expect(last_response.body).to eq 'at_least_one_of works!'
         end
       end
+
+      context 'nested params' do
+        before :each do
+          subject.params do
+            requires :nested, type: Hash do
+              optional :beer_nested
+              optional :wine_nested
+              optional :juice_nested
+              at_least_one_of :beer_nested, :wine_nested, :juice_nested
+            end
+            optional :nested2, type: Array do
+              optional :beer_nested2
+              optional :wine_nested2
+              optional :juice_nested2
+              at_least_one_of :beer_nested2, :wine_nested2, :juice_nested2
+            end
+          end
+          subject.get '/at_least_one_of_nested' do
+            'at_least_one_of works!'
+          end
+        end
+
+        it 'errors when none are present' do
+          get '/at_least_one_of_nested'
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq 'nested is missing, beer_nested, wine_nested, juice_nested are missing, at least one parameter must be provided'
+        end
+
+        it 'does not error when one is present' do
+          get '/at_least_one_of_nested', nested: { beer_nested: 'string' }, nested2: [{ beer_nested2: 'string' }]
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq 'at_least_one_of works!'
+        end
+
+        it 'does not error when two are present' do
+          get '/at_least_one_of_nested', nested: { beer_nested: 'string', wine_nested: 'string' }, nested2: [{ beer_nested2: 'string', wine_nested2: 'string' }]
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq 'at_least_one_of works!'
+        end
+      end
+    end
+
+    context 'in a group' do
+      it 'works when only one from the set is present' do
+        subject.params do
+          group :drink, type: Hash do
+            optional :wine
+            optional :beer
+            optional :juice
+
+            exactly_one_of :beer, :wine, :juice
+          end
+        end
+        subject.get '/exactly_one_of_group' do
+          'exactly_one_of_group works!'
+        end
+
+        get '/exactly_one_of_group', drink: { beer: 'true' }
+        expect(last_response.status).to eq(200)
+      end
+
+      it 'errors when no parameter from the set is present' do
+        subject.params do
+          group :drink, type: Hash do
+            optional :wine
+            optional :beer
+            optional :juice
+
+            exactly_one_of :beer, :wine, :juice
+          end
+        end
+        subject.get '/exactly_one_of_group' do
+          'exactly_one_of_group works!'
+        end
+
+        get '/exactly_one_of_group', drink: {}
+        expect(last_response.status).to eq(400)
+      end
+
+      it 'errors when more than one from the set is present' do
+        subject.params do
+          group :drink, type: Hash do
+            optional :wine
+            optional :beer
+            optional :juice
+
+            exactly_one_of :beer, :wine, :juice
+          end
+        end
+        subject.get '/exactly_one_of_group' do
+          'exactly_one_of_group works!'
+        end
+
+        get '/exactly_one_of_group', drink: { beer: 'true', juice: 'true', wine: 'true' }
+        expect(last_response.status).to eq(400)
+      end
+
+      it 'does not falsely think the param is there if it is provided outside the block' do
+        subject.params do
+          group :drink, type: Hash do
+            optional :wine
+            optional :beer
+            optional :juice
+
+            exactly_one_of :beer, :wine, :juice
+          end
+        end
+        subject.get '/exactly_one_of_group' do
+          'exactly_one_of_group works!'
+        end
+
+        get '/exactly_one_of_group', drink: { foo: 'bar' }, beer: 'true'
+        expect(last_response.status).to eq(400)
+      end
     end
   end
 end