grape 0.6.0 → 0.6.1

data/spec/grape/validations/presence_spec.rb

@@ -14,10 +14,10 @@ describe Grape::Validations::PresenceValidator do
         end
 
         params do
-          requires :id, :regexp => /^[0-9]+$/
+          requires :id, regexp: /^[0-9]+$/
         end
         post do
-          { :ret => params[:id] }
+          { ret: params[:id] }
         end
 
         params do
@@ -58,7 +58,7 @@ describe Grape::Validations::PresenceValidator do
   end
 
   it 'does not validate for any params' do
-    get("/bacons")
+    get "/bacons"
     last_response.status.should == 200
     last_response.body.should == "All the bacon".to_json
   end
@@ -69,74 +69,70 @@ describe Grape::Validations::PresenceValidator do
     last_response.body.should == '{"error":"id is missing"}'
 
     io = StringIO.new('{"id" : "a56b"}')
-    post '/', {}, 'rack.input' => io,
-      'CONTENT_TYPE' => 'application/json',
-      'CONTENT_LENGTH' => io.length
+    post '/', {}, 'rack.input' => io, 'CONTENT_TYPE' => 'application/json', 'CONTENT_LENGTH' => io.length
     last_response.body.should == '{"error":"id is invalid"}'
     last_response.status.should == 400
 
     io = StringIO.new('{"id" : 56}')
-    post '/', {}, 'rack.input' => io,
-      'CONTENT_TYPE' => 'application/json',
-      'CONTENT_LENGTH' => io.length
+    post '/', {}, 'rack.input' => io, 'CONTENT_TYPE' => 'application/json', 'CONTENT_LENGTH' => io.length
     last_response.body.should == '{"ret":56}'
     last_response.status.should == 201
   end
 
   it 'validates name, company' do
-    get('/')
+    get '/'
     last_response.status.should == 400
     last_response.body.should == '{"error":"name is missing"}'
 
-    get('/', :name => "Bob")
+    get '/', name: "Bob"
     last_response.status.should == 400
     last_response.body.should == '{"error":"company is missing"}'
 
-    get('/', :name => "Bob", :company => "TestCorp")
+    get '/', name: "Bob", company: "TestCorp"
     last_response.status.should == 200
     last_response.body.should == "Hello".to_json
   end
 
   it 'validates nested parameters' do
-    get('/nested')
+    get '/nested'
     last_response.status.should == 400
     last_response.body.should == '{"error":"user[first_name] is missing"}'
 
-    get('/nested', :user => {:first_name => "Billy"})
+    get '/nested', user: { first_name: "Billy" }
     last_response.status.should == 400
     last_response.body.should == '{"error":"user[last_name] is missing"}'
 
-    get('/nested', :user => {:first_name => "Billy", :last_name => "Bob"})
+    get '/nested', user: { first_name: "Billy", last_name: "Bob" }
     last_response.status.should == 200
     last_response.body.should == "Nested".to_json
   end
 
   it 'validates triple nested parameters' do
-    get('/nested_triple')
+    get '/nested_triple'
     last_response.status.should == 400
     last_response.body.should == '{"error":"admin[admin_name] is missing, admin[super][user][first_name] is missing"}'
 
-    get('/nested_triple', :user => {:first_name => "Billy"})
+    get '/nested_triple', user: { first_name: "Billy" }
     last_response.status.should == 400
     last_response.body.should == '{"error":"admin[admin_name] is missing, admin[super][user][first_name] is missing"}'
 
-    get('/nested_triple', :admin => {:super => {:first_name => "Billy"}})
+    get '/nested_triple', admin: { super: { first_name: "Billy" } }
     last_response.status.should == 400
     last_response.body.should == '{"error":"admin[admin_name] is missing, admin[super][user][first_name] is missing"}'
 
-    get('/nested_triple', :super => {:user => {:first_name => "Billy", :last_name => "Bob"}})
+    get '/nested_triple', super: { user: { first_name: "Billy", last_name: "Bob" } }
     last_response.status.should == 400
     last_response.body.should == '{"error":"admin[admin_name] is missing, admin[super][user][first_name] is missing"}'
 
-    get('/nested_triple', :admin => {:super => {:user => {:first_name => "Billy"}}})
+    get '/nested_triple', admin: { super: { user: { first_name: "Billy" } } }
     last_response.status.should == 400
     last_response.body.should == '{"error":"admin[admin_name] is missing, admin[super][user][last_name] is missing"}'
 
-    get('/nested_triple', :admin => { :admin_name => 'admin', :super => {:user => {:first_name => "Billy"}}})
+    get '/nested_triple', admin: { admin_name: 'admin', super: { user: { first_name: "Billy" } } }
     last_response.status.should == 400
     last_response.body.should == '{"error":"admin[super][user][last_name] is missing"}'
 
-    get('/nested_triple', :admin => { :admin_name => 'admin', :super => {:user => {:first_name => "Billy", :last_name => "Bob"}}})
+    get '/nested_triple', admin: { admin_name: 'admin', super: { user: { first_name: "Billy", last_name: "Bob" } } }
     last_response.status.should == 200
     last_response.body.should == "Nested triple".to_json
   end

data/spec/grape/validations/regexp_spec.rb

@@ -5,29 +5,29 @@ describe Grape::Validations::RegexpValidator do
     module RegexpValidatorSpec
       class API < Grape::API
         default_format :json
-        
+
         params do
-          requires :name, :regexp => /^[a-z]+$/
+          requires :name, regexp: /^[a-z]+$/
         end
         get do
-          
+
         end
       end
     end
   end
-  
+
   def app
     ValidationsSpec::RegexpValidatorSpec::API
   end
-  
+
   it 'refuses invalid input' do
-    get '/', :name => "invalid name"
+    get '/', name: "invalid name"
     last_response.status.should == 400
   end
-  
+
   it 'accepts valid input' do
-    get '/', :name => "bob"
+    get '/', name: "bob"
     last_response.status.should == 200
   end
-  
+
 end

data/spec/grape/validations/values_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Grape::Validations::ValuesValidator do
+
+  module ValidationsSpec
+    module ValuesValidatorSpec
+      class API < Grape::API
+        default_format :json
+
+        params do
+          requires :type, values: ['valid-type1', 'valid-type2', 'valid-type3']
+        end
+        get '/' do
+          { type: params[:type] }
+        end
+
+        params do
+          optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], default: 'valid-type2'
+        end
+        get '/default/valid' do
+          { type: params[:type] }
+        end
+
+      end
+    end
+  end
+
+  def app
+    ValidationsSpec::ValuesValidatorSpec::API
+  end
+
+  it 'allows a valid value for a parameter' do
+    get("/", type: 'valid-type1')
+    last_response.status.should eq 200
+    last_response.body.should eq({ type: "valid-type1" }.to_json)
+  end
+
+  it 'does not allow an invalid value for a parameter' do
+    get("/", type: 'invalid-type')
+    last_response.status.should eq 400
+    last_response.body.should eq({ error: "type does not have a valid value" }.to_json)
+  end
+
+  it 'allows a valid default value' do
+    get("/default/valid")
+    last_response.status.should eq 200
+    last_response.body.should eq({ type: "valid-type2" }.to_json)
+  end
+
+  it 'raises IncompatibleOptionValues on an invalid default value' do
+    subject = Class.new(Grape::API)
+    expect {
+      subject.params { optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], default: 'invalid-type' }
+    }.to raise_error Grape::Exceptions::IncompatibleOptionValues
+  end
+
+  it 'raises IncompatibleOptionValues when type is incompatible with values array' do
+    subject = Class.new(Grape::API)
+    expect {
+      subject.params { optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], type: Symbol }
+    }.to raise_error Grape::Exceptions::IncompatibleOptionValues
+  end
+
+end

data/spec/grape/validations_spec.rb

@@ -1,27 +1,39 @@
 require 'spec_helper'
 
 describe Grape::Validations do
+
   subject { Class.new(Grape::API) }
-  def app; subject end
+
+  def app
+    subject
+  end
 
   describe 'params' do
     context 'optional' do
       it 'validates when params is present' do
-        subject.params { optional :a_number, :regexp => /^[0-9]+$/ }
-        subject.get '/optional' do 'optional works!'; end
+        subject.params do
+          optional :a_number, regexp: /^[0-9]+$/
+        end
+        subject.get '/optional' do
+          'optional works!'
+        end
 
-        get '/optional', { :a_number => 'string' }
+        get '/optional', a_number: 'string'
         last_response.status.should == 400
         last_response.body.should == 'a_number is invalid'
 
-        get '/optional', { :a_number => 45 }
+        get '/optional', a_number: 45
         last_response.status.should == 200
         last_response.body.should == 'optional works!'
       end
 
       it "doesn't validate when param not present" do
-        subject.params { optional :a_number, :regexp => /^[0-9]+$/ }
-        subject.get '/optional' do 'optional works!'; end
+        subject.params do
+          optional :a_number, regexp: /^[0-9]+$/
+        end
+        subject.get '/optional' do
+          'optional works!'
+        end
 
         get '/optional'
         last_response.status.should == 200
@@ -29,15 +41,21 @@ describe Grape::Validations do
       end
 
       it 'adds to declared parameters' do
-        subject.params { optional :some_param }
+        subject.params do
+          optional :some_param
+        end
         subject.settings[:declared_params].should == [:some_param]
       end
     end
 
     context 'required' do
       before do
-        subject.params { requires :key }
-        subject.get '/required' do 'required works'; end
+        subject.params do
+          requires :key
+        end
+        subject.get '/required' do
+          'required works'
+        end
       end
 
       it 'errors when param not present' do
@@ -47,25 +65,29 @@ describe Grape::Validations do
       end
 
       it "doesn't throw a missing param when param is present" do
-        get '/required', { :key => 'cool' }
+        get '/required', key: 'cool'
         last_response.status.should == 200
         last_response.body.should == 'required works'
       end
 
       it 'adds to declared parameters' do
-        subject.params { requires :some_param }
+        subject.params do
+          requires :some_param
+        end
         subject.settings[:declared_params].should == [:some_param]
       end
     end
 
     context 'required with a block' do
       before do
-        subject.params {
+        subject.params do
           requires :items do
             requires :key
           end
-        }
-        subject.get '/required' do 'required works'; end
+        end
+        subject.get '/required' do
+          'required works'
+        end
       end
 
       it 'errors when param not present' do
@@ -75,39 +97,41 @@ describe Grape::Validations do
       end
 
       it "doesn't throw a missing param when param is present" do
-        get '/required', { :items => [:key => 'hello', :key => 'world'] }
+        get '/required', items: [key: 'hello', key: 'world']
         last_response.status.should == 200
         last_response.body.should == 'required works'
       end
 
       it "doesn't allow more than one parameter" do
         expect {
-          subject.params {
+          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 {
+        subject.params do
           requires :items do
             requires :key
           end
-        }
-        subject.settings[:declared_params].should == [:items => [:key]]
+        end
+        subject.settings[:declared_params].should == [items: [:key]]
       end
     end
 
     context 'group' do
       before do
-        subject.params {
+        subject.params do
           group :items do
             requires :key
           end
-        }
-        subject.get '/required' do 'required works'; end
+        end
+        subject.get '/required' do
+          'required works'
+        end
       end
 
       it 'errors when param not present' do
@@ -117,29 +141,31 @@ describe Grape::Validations do
       end
 
       it "doesn't throw a missing param when param is present" do
-        get '/required', { :items => [:key => 'hello', :key => 'world'] }
+        get '/required', items: [key: 'hello', key: 'world']
         last_response.status.should == 200
         last_response.body.should == 'required works'
       end
 
       it 'adds to declared parameters' do
-        subject.params {
+        subject.params do
           group :items do
             requires :key
           end
-        }
-        subject.settings[:declared_params].should == [:items => [:key]]
+        end
+        subject.settings[:declared_params].should == [items: [:key]]
       end
     end
 
     context 'optional with a block' do
       before do
-        subject.params {
+        subject.params do
           optional :items do
             requires :key
           end
-        }
-        subject.get '/optional_group' do 'optional group works'; end
+        end
+        subject.get '/optional_group' do
+          'optional group works'
+        end
       end
 
       it "doesn't throw a missing param when the group isn't present" do
@@ -149,36 +175,36 @@ describe Grape::Validations do
       end
 
       it "doesn't throw a missing param when both group and param are given" do
-        get '/optional_group', { :items => {:key => 'foo'} }
+        get '/optional_group', items: { key: 'foo' }
         last_response.status.should == 200
         last_response.body.should == 'optional group works'
       end
 
       it "errors when group is present, but required param is not" do
-        get '/optional_group', { :items => {:NOT_key => 'foo'} }
+        get '/optional_group', items: { not_key: 'foo' }
         last_response.status.should == 400
         last_response.body.should == 'items[key] is missing'
       end
 
       it 'adds to declared parameters' do
-        subject.params {
+        subject.params do
           optional :items do
             requires :key
           end
-        }
-        subject.settings[:declared_params].should == [:items => [:key]]
+        end
+        subject.settings[:declared_params].should == [items: [:key]]
       end
     end
 
     context 'nested optional blocks' do
       before do
-        subject.params {
+        subject.params do
           optional :items do
             requires :key
             optional(:optional_subitems) { requires :value }
             requires(:required_subitems) { requires :value }
           end
-        }
+        end
         subject.get('/nested_optional_group') { 'nested optional group works' }
       end
 
@@ -189,41 +215,46 @@ describe Grape::Validations do
       end
 
       it 'does internal validations if the outer group is present' do
-        get '/nested_optional_group', { :items => {:key => 'foo' }}
+        get '/nested_optional_group', items: { key: 'foo' }
         last_response.status.should == 400
         last_response.body.should == 'items[required_subitems][value] is missing'
 
-        get '/nested_optional_group', { :items => { :key => 'foo', :required_subitems => {:value => 'bar'}}}
+        get '/nested_optional_group', items: { key: 'foo', required_subitems: { value: 'bar' } }
         last_response.status.should == 200
         last_response.body.should == 'nested optional group works'
       end
 
       it 'handles deep nesting' do
-        get '/nested_optional_group', { :items => { :key => 'foo', :required_subitems => {:value => 'bar'}, :optional_subitems => {:NOT_value => 'baz'}}}
+        get '/nested_optional_group', items: { key: 'foo', required_subitems: { value: 'bar' }, optional_subitems: { not_value: 'baz' } }
         last_response.status.should == 400
         last_response.body.should == 'items[optional_subitems][value] is missing'
 
-        get '/nested_optional_group', { :items => { :key => 'foo', :required_subitems => {:value => 'bar'}, :optional_subitems => {:value => 'baz'}}}
+        get '/nested_optional_group', items: { key: 'foo', required_subitems: { value: 'bar' }, optional_subitems: { value: 'baz' } }
         last_response.status.should == 200
         last_response.body.should == 'nested optional group works'
       end
 
       it 'adds to declared parameters' do
-        subject.params {
+        subject.params do
           optional :items do
             requires :key
             optional(:optional_subitems) { requires :value }
             requires(:required_subitems) { requires :value }
           end
-        }
-        subject.settings[:declared_params].should == [:items => [:key, {:optional_subitems => [:value]}, {:required_subitems => [:value]}]]
+        end
+        subject.settings[:declared_params].should == [items: [:key, { optional_subitems: [:value] }, { required_subitems: [:value] }]]
       end
     end
 
     context 'multiple validation errors' do
       before do
-        subject.params { requires :yolo; requires :swag }
-        subject.get '/two_required' do 'two required works'; end
+        subject.params do
+          requires :yolo
+          requires :swag
+        end
+        subject.get '/two_required' do
+          'two required works'
+        end
       end
 
       it 'throws the validation errors' do
@@ -239,7 +270,7 @@ describe Grape::Validations do
         class Customvalidator < Grape::Validations::Validator
           def validate_param!(attr_name, params)
             unless params[attr_name] == 'im custom'
-              raise Grape::Exceptions::Validation, :param => @scope.full_name(attr_name), :message => "is not custom!"
+              raise Grape::Exceptions::Validation, param: @scope.full_name(attr_name), message: "is not custom!"
             end
           end
         end
@@ -247,16 +278,20 @@ describe Grape::Validations do
 
       context 'when using optional with a custom validator' do
         before do
-          subject.params { optional :custom, :customvalidator => true }
-          subject.get '/optional_custom' do 'optional with custom works!'; end
+          subject.params do
+            optional :custom, customvalidator: true
+          end
+          subject.get '/optional_custom' do
+            'optional with custom works!'
+          end
         end
 
         it 'validates when param is present' do
-          get '/optional_custom', { :custom => 'im custom' }
+          get '/optional_custom', { custom: 'im custom' }
           last_response.status.should == 200
           last_response.body.should == 'optional with custom works!'
 
-          get '/optional_custom', { :custom => 'im wrong' }
+          get '/optional_custom', { custom: 'im wrong' }
           last_response.status.should == 400
           last_response.body.should == 'custom is not custom!'
         end
@@ -268,9 +303,11 @@ describe Grape::Validations do
         end
 
         it 'validates with custom validator when param present and incorrect type' do
-          subject.params { optional :custom, :type => String, :customvalidator => true }
+          subject.params do
+            optional :custom, type: String, customvalidator: true
+          end
 
-          get '/optional_custom', { :custom => 123 }
+          get '/optional_custom', custom: 123
           last_response.status.should == 400
           last_response.body.should == 'custom is not custom!'
         end
@@ -278,16 +315,20 @@ describe Grape::Validations do
 
       context 'when using requires with a custom validator' do
         before do
-          subject.params { requires :custom, :customvalidator => true }
-          subject.get '/required_custom' do 'required with custom works!'; end
+          subject.params do
+            requires :custom, customvalidator: true
+          end
+          subject.get '/required_custom' do
+            'required with custom works!'
+          end
         end
 
         it 'validates when param is present' do
-          get '/required_custom', { :custom => 'im wrong, validate me' }
+          get '/required_custom', custom: 'im wrong, validate me'
           last_response.status.should == 400
           last_response.body.should == 'custom is not custom!'
 
-          get '/required_custom', { :custom => 'im custom' }
+          get '/required_custom', custom: 'im custom'
           last_response.status.should == 200
           last_response.body.should == 'required with custom works!'
         end
@@ -300,50 +341,66 @@ describe Grape::Validations do
 
         context 'nested namespaces' do
           before do
-            subject.params { requires :custom, :customvalidator => true }
+            subject.params do
+              requires :custom, customvalidator: true
+            end
             subject.namespace 'nested' do
-              get 'one' do 'validation failed' end
+              get 'one' do
+                'validation failed'
+              end
               namespace 'nested' do
-                get 'two' do 'validation failed' end
+                get 'two' do
+                  'validation failed'
+                end
               end
             end
             subject.namespace 'peer' do
-              get 'one' do 'no validation required' end
+              get 'one' do
+                'no validation required'
+              end
               namespace 'nested' do
-                get 'two' do 'no validation required' end
+                get 'two' do
+                  'no validation required'
+                end
               end
             end
 
             subject.namespace 'unrelated' do
-              params{ requires :name }
-              get 'one' do 'validation required'; end
+              params do
+                requires :name
+              end
+              get 'one' do
+                'validation required'
+              end
 
               namespace 'double' do
-                get 'two' do 'no validation required' end
+                get 'two' do
+                  'no validation required'
+                end
               end
             end
           end
 
           specify 'the parent namespace uses the validator' do
-            get '/nested/one', { :custom => 'im wrong, validate me'}
+            get '/nested/one', custom: 'im wrong, validate me'
             last_response.status.should == 400
             last_response.body.should == 'custom is not custom!'
           end
 
           specify 'the nested namesapce inherits the custom validator' do
-            get '/nested/nested/two', { :custom => 'im wrong, validate me'}
+            get '/nested/nested/two', custom: 'im wrong, validate me'
             last_response.status.should == 400
             last_response.body.should == 'custom is not custom!'
           end
 
           specify 'peer namesapces does not have the validator' do
-            get '/peer/one', { :custom => 'im not validated' }
+            get '/peer/one', custom: 'im not validated'
             last_response.status.should == 200
             last_response.body.should == 'no validation required'
           end
 
           specify 'namespaces nested in peers should also not have the validator' do
-            get '/peer/nested/two', { :custom => 'im not validated' }
+            get '/peer/nested/two', custom: 'im not validated'
             last_response.status.should == 200
             last_response.body.should == 'no validation required'
           end