grape 0.3.0 → 0.7.0

data/spec/grape/util/hash_stack_spec.rb

@@ -1,12 +1,11 @@
 require 'spec_helper'
 
 describe Grape::Util::HashStack do
-  let(:klass){ Grape::Util::HashStack }
 
   describe '#get' do
     it 'finds the first available key' do
       subject[:abc] = 123
-      subject.push(:abc => 345)
+      subject.push(abc: 345)
       subject.get(:abc).should == 345
     end
 
@@ -26,105 +25,105 @@ describe Grape::Util::HashStack do
   describe '#imbue' do
     it 'pushes a new value onto the end of an array' do
       subject[:abc] = []
-      subject.imbue(:abc, [123])
-      subject.imbue(:abc, [456])
+      subject.imbue :abc, [123]
+      subject.imbue :abc, [456]
       subject[:abc].should == [123, 456]
     end
 
     it 'merges a hash that is passed' do
-      subject[:abc] = {:foo => 'bar'}
-      subject.imbue(:abc, {:baz => 'wich'})
-      subject[:abc].should == {:foo => 'bar', :baz => 'wich'}
+      subject[:abc] = { foo: 'bar' }
+      subject.imbue :abc, baz: 'wich'
+      subject[:abc].should == { foo: 'bar', baz: 'wich' }
     end
 
     it 'sets the value if not a hash or array' do
-      subject.imbue(:abc, 123)
+      subject.imbue :abc, 123
       subject[:abc].should == 123
     end
 
     it 'is able to imbue an array without explicit setting' do
-      subject.imbue(:arr, [1])
-      subject.imbue(:arr, [2])
-      subject[:arr].should == [1,2]
+      subject.imbue :arr, [1]
+      subject.imbue :arr, [2]
+      subject[:arr].should == [1, 2]
     end
 
     it 'is able to imbue a hash without explicit setting' do
-      subject.imbue(:hash, :foo => 'bar')
-      subject.imbue(:hash, :baz => 'wich')
-      subject[:hash].should == {:foo => 'bar', :baz => 'wich'}
+      subject.imbue :hash, foo: 'bar'
+      subject.imbue :hash, baz: 'wich'
+      subject[:hash].should == { foo: 'bar', baz: 'wich' }
     end
   end
 
   describe '#push' do
     it 'returns a HashStack' do
-      subject.push(klass.new).should be_kind_of(klass)
+      subject.push(Grape::Util::HashStack.new).should be_kind_of(Grape::Util::HashStack)
     end
 
     it 'places the passed value on the top of the stack' do
-      subject.push(:abc => 123)
-      subject.stack.should == [{}, {:abc => 123}]
+      subject.push(abc: 123)
+      subject.stack.should == [{}, { abc: 123 }]
     end
 
     it 'pushes an empty hash by default' do
       subject[:abc] = 123
       subject.push
-      subject.stack.should == [{:abc => 123}, {}]
+      subject.stack.should == [{ abc: 123 }, {}]
     end
   end
 
   describe '#pop' do
     it 'removes and return the top frame' do
-      subject.push(:abc => 123)
-      subject.pop.should == {:abc => 123}
+      subject.push(abc: 123)
+      subject.pop.should == { abc: 123 }
       subject.stack.size.should == 1
     end
   end
 
   describe '#peek' do
     it 'returns the top frame without removing it' do
-      subject.push(:abc => 123)
-      subject.peek.should == {:abc => 123}
+      subject.push(abc: 123)
+      subject.peek.should == { abc: 123 }
       subject.stack.size.should == 2
     end
   end
 
   describe '#prepend' do
     it 'returns a HashStack' do
-      subject.prepend(klass.new).should be_kind_of(klass)
+      subject.prepend(Grape::Util::HashStack.new).should be_kind_of(Grape::Util::HashStack)
     end
 
     it "prepends a HashStack's stack onto its own stack" do
-      other = klass.new.push(:abc => 123)
-      subject.prepend(other).stack.should == [{}, {:abc => 123}, {}]
+      other = Grape::Util::HashStack.new.push(abc: 123)
+      subject.prepend(other).stack.should == [{}, { abc: 123 }, {}]
     end
   end
 
   describe '#concat' do
     it 'returns a HashStack' do
-      subject.concat(klass.new).should be_kind_of(klass)
+      subject.concat(Grape::Util::HashStack.new).should be_kind_of(Grape::Util::HashStack)
     end
 
     it "appends a HashStack's stack onto its own stack" do
-      other = klass.new.push(:abc => 123)
-      subject.concat(other).stack.should == [{}, {}, {:abc => 123}]
+      other = Grape::Util::HashStack.new.push(abc: 123)
+      subject.concat(other).stack.should == [{}, {}, { abc: 123 }]
     end
   end
 
   describe '#update' do
     it 'merges! into the top frame' do
-      subject.update(:abc => 123)
-      subject.stack.should == [{:abc => 123}]
+      subject.update(abc: 123)
+      subject.stack.should == [{ abc: 123 }]
     end
 
     it 'returns a HashStack' do
-      subject.update(:abc => 123).should be_kind_of(klass)
+      subject.update(abc: 123).should be_kind_of(Grape::Util::HashStack)
     end
   end
 
   describe '#clone' do
     it 'performs a deep copy' do
       subject[:abc] = 123
-      subject.push :def => 234
+      subject.push def: 234
       clone = subject.clone
       clone[:def] = 345
       subject[:def].should == 234

data/spec/grape/validations/coerce_spec.rb

@@ -2,45 +2,84 @@
 require 'spec_helper'
 
 describe Grape::Validations::CoerceValidator do
-  subject { Class.new(Grape::API) }
-  def app; subject end
+  subject do
+    Class.new(Grape::API)
+  end
+
+  def app
+    subject
+  end
 
   describe 'coerce' do
-    it "i18n error on malformed input" do
-      I18n.load_path << File.expand_path('../zh-CN.yml',__FILE__)
-      I18n.reload!
-      I18n.locale = :'zh-CN'
-      subject.params { requires :age, :type => Integer }
-      subject.get '/single' do 'int works'; end
-
-      get '/single', :age => '43a'
-      last_response.status.should == 400
-      last_response.body.should == '年龄格式不正确'
-      I18n.locale = :en
+
+    context "i18n" do
+
+      after :each do
+        I18n.locale = :en
+      end
+
+      it "i18n error on malformed input" do
+        I18n.load_path << File.expand_path('../zh-CN.yml', __FILE__)
+        I18n.reload!
+        I18n.locale = 'zh-CN'.to_sym
+        subject.params do
+          requires :age, type: Integer
+        end
+        subject.get '/single' do
+          'int works'
+        end
+
+        get '/single', age: '43a'
+        last_response.status.should == 400
+        last_response.body.should == '年龄格式不正确'
+      end
+
+      it 'gives an english fallback error when default locale message is blank' do
+        I18n.locale = 'pt-BR'.to_sym
+        subject.params do
+          requires :age, type: Integer
+        end
+        subject.get '/single' do
+          'int works'
+        end
+
+        get '/single', age: '43a'
+        last_response.status.should == 400
+        last_response.body.should == 'age is invalid'
+      end
 
     end
+
     it 'error on malformed input' do
-      subject.params { requires :int, :type => Integer }
-      subject.get '/single' do 'int works'; end
+      subject.params do
+        requires :int, type: Integer
+      end
+      subject.get '/single' do
+        'int works'
+      end
 
-      get '/single', :int => '43a'
+      get '/single', int: '43a'
       last_response.status.should == 400
-      last_response.body.should == 'invalid parameter: int'
+      last_response.body.should == 'int is invalid'
 
-      get '/single', :int => '43'
+      get '/single', int: '43'
       last_response.status.should == 200
       last_response.body.should == 'int works'
     end
 
     it 'error on malformed input (Array)' do
-      subject.params { requires :ids, :type => Array[Integer] }
-      subject.get '/array' do 'array int works'; end
+      subject.params do
+        requires :ids, type: Array[Integer]
+      end
+      subject.get '/array' do
+        'array int works'
+      end
 
-      get 'array', { :ids => ['1', '2', 'az'] }
+      get 'array', ids: ['1', '2', 'az']
       last_response.status.should == 400
-      last_response.body.should == 'invalid parameter: ids'
+      last_response.body.should == 'ids is invalid'
 
-      get 'array', { :ids => ['1', '2', '890'] }
+      get 'array', ids: ['1', '2', '890']
       last_response.status.should == 200
       last_response.body.should == 'array int works'
     end
@@ -48,21 +87,25 @@ describe Grape::Validations::CoerceValidator do
     context 'complex objects' do
       module CoerceValidatorSpec
         class User
-          include Virtus
+          include Virtus.model
           attribute :id, Integer
           attribute :name, String
         end
       end
 
       it 'error on malformed input for complex objects' do
-        subject.params { requires :user, :type => CoerceValidatorSpec::User }
-        subject.get '/user' do 'complex works'; end
+        subject.params do
+          requires :user, type: CoerceValidatorSpec::User
+        end
+        subject.get '/user' do
+          'complex works'
+        end
 
-        get '/user', :user => "32"
+        get '/user', user: "32"
         last_response.status.should == 400
-        last_response.body.should == 'invalid parameter: user'
+        last_response.body.should == 'user is invalid'
 
-        get '/user', :user => { :id => 32, :name => 'Bob' }
+        get '/user', user: { id: 32, name: 'Bob' }
         last_response.status.should == 200
         last_response.body.should == 'complex works'
       end
@@ -70,71 +113,93 @@ describe Grape::Validations::CoerceValidator do
 
     context 'coerces' do
       it 'Integer' do
-        subject.params { requires :int, :coerce => Integer }
-        subject.get '/int' do params[:int].class; end
+        subject.params do
+          requires :int, coerce: Integer
+        end
+        subject.get '/int' do
+          params[:int].class
+        end
 
-        get '/int', { :int => "45" }
+        get '/int', int: "45"
         last_response.status.should == 200
         last_response.body.should == 'Fixnum'
       end
 
       it 'Array of Integers' do
-        subject.params { requires :arry, :coerce => Array[Integer] }
-        subject.get '/array' do params[:arry][0].class; end
+        subject.params do
+          requires :arry, coerce: Array[Integer]
+        end
+        subject.get '/array' do
+          params[:arry][0].class
+        end
 
-        get '/array', { :arry => [ '1', '2', '3' ] }
+        get '/array', arry: ['1', '2', '3']
         last_response.status.should == 200
         last_response.body.should == 'Fixnum'
       end
 
       it 'Array of Bools' do
-        subject.params { requires :arry, :coerce => Array[Virtus::Attribute::Boolean] }
-        subject.get '/array' do params[:arry][0].class; end
+        subject.params do
+          requires :arry, coerce: Array[Virtus::Attribute::Boolean]
+        end
+        subject.get '/array' do
+          params[:arry][0].class
+        end
 
-        get 'array', { :arry => [1, 0] }
+        get 'array', arry: [1, 0]
         last_response.status.should == 200
         last_response.body.should == 'TrueClass'
       end
 
       it 'Bool' do
-        subject.params { requires :bool, :coerce => Virtus::Attribute::Boolean }
-        subject.get '/bool' do params[:bool].class; end
+        subject.params do
+          requires :bool, coerce: Virtus::Attribute::Boolean
+        end
+        subject.get '/bool' do
+          params[:bool].class
+        end
 
-        get '/bool', { :bool => 1 }
+        get '/bool', bool: 1
         last_response.status.should == 200
         last_response.body.should == 'TrueClass'
 
-        get '/bool', { :bool => 0 }
+        get '/bool', bool: 0
         last_response.status.should == 200
         last_response.body.should == 'FalseClass'
 
-        get '/bool', { :bool => 'false' }
+        get '/bool', bool: 'false'
         last_response.status.should == 200
         last_response.body.should == 'FalseClass'
 
-        get '/bool', { :bool => 'true' }
+        get '/bool', bool: 'true'
         last_response.status.should == 200
         last_response.body.should == 'TrueClass'
       end
 
       it 'file' do
-        subject.params { requires :file, :coerce => Rack::Multipart::UploadedFile }
-        subject.post '/upload' do params[:file].filename; end
+        subject.params do
+          requires :file, coerce: Rack::Multipart::UploadedFile
+        end
+        subject.post '/upload' do
+          params[:file].filename
+        end
 
-        post '/upload', { :file => Rack::Test::UploadedFile.new(__FILE__) }
+        post '/upload', file: Rack::Test::UploadedFile.new(__FILE__)
         last_response.status.should == 201
         last_response.body.should == File.basename(__FILE__).to_s
       end
 
       it 'Nests integers' do
         subject.params do
-          group :integers do
-            requires :int, :coerce => Integer
+          requires :integers, type: Hash do
+            requires :int, coerce: Integer
           end
         end
-        subject.get '/int' do params[:integers][:int].class; end
+        subject.get '/int' do
+          params[:integers][:int].class
+        end
 
-        get '/int', { :integers => { :int => "45" } }
+        get '/int', integers: { int: "45" }
         last_response.status.should == 200
         last_response.body.should == 'Fixnum'
       end

data/spec/grape/validations/default_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Grape::Validations::DefaultValidator do
+
+  module ValidationsSpec
+    module DefaultValidatorSpec
+      class API < Grape::API
+        default_format :json
+
+        params do
+          optional :id
+          optional :type, default: 'default-type'
+        end
+        get '/' do
+          { id: params[:id], type: params[:type] }
+        end
+
+        params do
+          optional :type1, default: 'default-type1'
+          optional :type2, default: 'default-type2'
+        end
+        get '/user' do
+          { type1: params[:type1], type2: params[:type2] }
+        end
+
+        params do
+          requires :id
+          optional :type1, default: 'default-type1'
+          optional :type2, default: 'default-type2'
+        end
+
+        get '/message' do
+          { id: params[:id], type1: params[:type1], type2: params[:type2] }
+        end
+
+        params do
+          optional :random, default: -> { Random.rand }
+          optional :not_random, default: Random.rand
+        end
+        get '/numbers' do
+          { random_number: params[:random], non_random_number: params[:non_random_number] }
+        end
+
+        params do
+          # NOTE: The :foo parameter could be made required with json body
+          # params, and then an empty hash would be valid. With query parameters
+          # it must be optional if it isn't provided at all, as otherwise
+          # the validaton for the Hash itself fails because there is no such
+          # thing as an empty hash.
+          optional :foo, type: Hash do
+            optional :bar, default: 'foo-bar'
+          end
+        end
+        get '/group' do
+          { foo_bar: params[:foo][:bar] }
+        end
+
+        params do
+          optional :array, type: Array do
+            requires :name
+            optional :with_default, default: 'default'
+          end
+        end
+        get '/array' do
+          { array: params[:array] }
+        end
+      end
+    end
+  end
+
+  def app
+    ValidationsSpec::DefaultValidatorSpec::API
+  end
+
+  it 'set default value for optional param' do
+    get("/")
+    last_response.status.should == 200
+    last_response.body.should == { id: nil, type: 'default-type' }.to_json
+  end
+
+  it 'set default values for optional params' do
+    get("/user")
+    last_response.status.should == 200
+    last_response.body.should == { type1: 'default-type1', type2: 'default-type2' }.to_json
+  end
+
+  it 'set default values for missing params in the request' do
+    get("/user?type2=value2")
+    last_response.status.should == 200
+    last_response.body.should == { type1: 'default-type1', type2: 'value2' }.to_json
+  end
+
+  it 'set default values for optional params and allow to use required fields in the same time' do
+    get("/message?id=1")
+    last_response.status.should == 200
+    last_response.body.should == { id: '1', type1: 'default-type1', type2: 'default-type2' }.to_json
+  end
+
+  it 'sets lambda based defaults at the time of call' do
+    get("/numbers")
+    last_response.status.should == 200
+    before = JSON.parse(last_response.body)
+    get("/numbers")
+    last_response.status.should == 200
+    after = JSON.parse(last_response.body)
+
+    before['non_random_number'].should == after['non_random_number']
+    before['random_number'].should_not == after['random_number']
+  end
+
+  it 'set default values for optional grouped params' do
+    get('/group')
+    last_response.status.should == 200
+    last_response.body.should == { foo_bar: 'foo-bar' }.to_json
+  end
+
+  it 'sets default values for grouped arrays' do
+    get('/array?array[][name]=name&array[][name]=name2&array[][with_default]=bar2')
+    last_response.status.should == 200
+    last_response.body.should == { array: [{ name: "name", with_default: "default" }, { name: "name2", with_default: "bar2" }] }.to_json
+  end
+
+end