grape 0.14.0 → 0.15.0

data/lib/grape/validations/validators/regexp.rb

@@ -2,8 +2,8 @@ module Grape
   module Validations
     class RegexpValidator < Base
       def validate_param!(attr_name, params)
-        return unless params.key?(attr_name) && !params[attr_name].nil? && !(params[attr_name].to_s =~ @option)
-        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :regexp
+        return unless params.key?(attr_name) && !params[attr_name].nil? && !(params[attr_name].to_s =~ (options_key?(:value) ? @option[:value] : @option))
+        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:regexp)
       end
     end
   end

data/lib/grape/validations/validators/values.rb

@@ -2,7 +2,7 @@ module Grape
   module Validations
     class ValuesValidator < Base
       def initialize(attrs, options, required, scope)
-        @values = options
+        @values = (options_key?(:value, options) ? options[:value] : options)
         super
       end
 
@@ -13,7 +13,7 @@ module Grape
         values = @values.is_a?(Proc) ? @values.call : @values
         param_array = params[attr_name].nil? ? [nil] : Array.wrap(params[attr_name])
         return if param_array.all? { |param| values.include?(param) }
-        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :values
+        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:values)
       end
 
       private

data/lib/grape/version.rb

@@ -1,4 +1,4 @@
 module Grape
   # The current version of Grape.
-  VERSION = '0.14.0'
+  VERSION = '0.15.0'
 end

data/spec/grape/api/custom_validations_spec.rb

@@ -1,34 +1,33 @@
 require 'spec_helper'
 
 describe Grape::Validations do
-  before do
-    module CustomValidationsSpec
-      class DefaultLength < Grape::Validations::Base
-        def validate_param!(attr_name, params)
-          @option = params[:max].to_i if params.key?(:max)
-          return if params[attr_name].length <= @option
-          fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: "must be at the most #{@option} characters long"
+  context 'using a custom length validator' do
+    before do
+      module CustomValidationsSpec
+        class DefaultLength < Grape::Validations::Base
+          def validate_param!(attr_name, params)
+            @option = params[:max].to_i if params.key?(:max)
+            return if params[attr_name].length <= @option
+            fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: "must be at the most #{@option} characters long"
+          end
         end
       end
     end
-  end
-
-  subject do
-    Class.new(Grape::API) do
-      params do
-        requires :text, default_length: 140
-      end
-      get do
-        'bacon'
+    subject do
+      Class.new(Grape::API) do
+        params do
+          requires :text, default_length: 140
+        end
+        get do
+          'bacon'
+        end
       end
     end
-  end
 
-  def app
-    subject
-  end
+    def app
+      subject
+    end
 
-  context 'using a custom length validator' do
     it 'under 140 characters' do
       get '/', text: 'abc'
       expect(last_response.status).to eq 200
@@ -45,4 +44,140 @@ describe Grape::Validations do
       expect(last_response.body).to eq 'bacon'
     end
   end
+
+  context 'using a custom body-only validator' do
+    before do
+      module CustomValidationsSpec
+        class InBody < Grape::Validations::PresenceValidator
+          def validate(request)
+            validate!(request.env['api.request.body'])
+          end
+        end
+      end
+    end
+    subject do
+      Class.new(Grape::API) do
+        params do
+          requires :text, in_body: true
+        end
+        get do
+          'bacon'
+        end
+      end
+    end
+
+    def app
+      subject
+    end
+
+    it 'allows field in body' do
+      get '/', text: 'abc'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'bacon'
+    end
+    it 'ignores field in query' do
+      get '/', nil, text: 'abc'
+      expect(last_response.status).to eq 400
+      expect(last_response.body).to eq 'text is missing'
+    end
+  end
+
+  context 'using a custom validator with message_key' do
+    before do
+      module CustomValidationsSpec
+        class WithMessageKey < Grape::Validations::PresenceValidator
+          def validate_param!(attr_name, _params)
+            fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: :presence
+          end
+        end
+      end
+    end
+    subject do
+      Class.new(Grape::API) do
+        params do
+          requires :text, with_message_key: true
+        end
+        get do
+          'bacon'
+        end
+      end
+    end
+
+    def app
+      subject
+    end
+
+    it 'fails with message' do
+      get '/', text: 'foobar'
+      expect(last_response.status).to eq 400
+      expect(last_response.body).to eq 'text is missing'
+    end
+  end
+
+  context 'using a custom request/param validator' do
+    before do
+      module CustomValidationsSpec
+        class Admin < Grape::Validations::Base
+          def validate(request)
+            # return if the param we are checking was not in request
+            # @attrs is a list containing the attribute we are currently validating
+            return unless request.params.key? @attrs.first
+            # check if admin flag is set to true
+            return unless @option
+            # check if user is admin or not
+            # as an example get a token from request and check if it's admin or not
+            fail Grape::Exceptions::Validation, params: @attrs, message: 'Can not set Admin only field.' unless request.headers['X-Access-Token'] == 'admin'
+          end
+        end
+      end
+    end
+    subject do
+      Class.new(Grape::API) do
+        params do
+          optional :admin_field, type: String, admin: true
+          optional :non_admin_field, type: String
+          optional :admin_false_field, type: String, admin: false
+        end
+        get do
+          'bacon'
+        end
+      end
+    end
+
+    def app
+      subject
+    end
+
+    it 'fail when non-admin user sets an admin field' do
+      get '/', admin_field: 'tester', non_admin_field: 'toaster'
+      expect(last_response.status).to eq 400
+      expect(last_response.body).to include 'Can not set Admin only field.'
+    end
+
+    it 'does not fail when we send non-admin fields only' do
+      get '/', non_admin_field: 'toaster'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'bacon'
+    end
+
+    it 'does not fail when we send non-admin and admin=false fields only' do
+      get '/', non_admin_field: 'toaster', admin_false_field: 'test'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'bacon'
+    end
+
+    it 'does not fail when we send admin fields and we are admin' do
+      header 'X-Access-Token', 'admin'
+      get '/', admin_field: 'tester', non_admin_field: 'toaster', admin_false_field: 'test'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'bacon'
+    end
+
+    it 'fails when we send admin fields and we are not admin' do
+      header 'X-Access-Token', 'user'
+      get '/', admin_field: 'tester', non_admin_field: 'toaster', admin_false_field: 'test'
+      expect(last_response.status).to eq 400
+      expect(last_response.body).to include 'Can not set Admin only field.'
+    end
+  end
 end

data/spec/grape/api/namespace_parameters_in_route_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Grape::Endpoint do
+  subject { Class.new(Grape::API) }
+
+  def app
+    subject
+  end
+
+  before do
+    subject.namespace :me do
+      namespace :pending do
+        get '/' do
+          'banana'
+        end
+      end
+      put ':id' do
+        params[:id]
+      end
+    end
+  end
+
+  context 'get' do
+    it 'responds without ext' do
+      get '/me/pending'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'banana'
+    end
+  end
+
+  context 'put' do
+    it 'responds' do
+      put '/me/foo'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'foo'
+    end
+  end
+end

data/spec/grape/api/optional_parameters_in_route_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Grape::Endpoint do
+  subject { Class.new(Grape::API) }
+
+  def app
+    subject
+  end
+
+  before do
+    subject.namespace :api do
+      get ':id(/:ext)' do
+        [params[:id], params[:ext]].compact.join('/')
+      end
+
+      put ':id' do
+        params[:id]
+      end
+    end
+  end
+
+  context 'get' do
+    it 'responds without ext' do
+      get '/api/foo'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'foo'
+    end
+
+    it 'responds with ext' do
+      get '/api/foo/bar'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'foo/bar'
+    end
+  end
+
+  context 'put' do
+    it 'responds' do
+      put '/api/foo'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'foo'
+    end
+  end
+end

data/spec/grape/api/required_parameters_in_route_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Grape::Endpoint do
+  subject { Class.new(Grape::API) }
+
+  def app
+    subject
+  end
+
+  before do
+    subject.namespace :api do
+      get ':id' do
+        [params[:id], params[:ext]].compact.join('/')
+      end
+
+      put ':something_id' do
+        params[:something_id]
+      end
+    end
+  end
+
+  context 'get' do
+    it 'responds' do
+      get '/api/foo'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'foo'
+    end
+  end
+
+  context 'put' do
+    it 'responds' do
+      put '/api/foo'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'foo'
+    end
+  end
+end

data/spec/grape/api_spec.rb

@@ -136,7 +136,7 @@ describe Grape::API do
     it 'adds the association to the :representations setting' do
       klass = Class.new
       subject.represent Object, with: klass
-      expect(Grape::DSL::Configuration.stacked_hash_to_hash(subject.namespace_stackable(:representations))[Object]).to eq(klass)
+      expect(subject.namespace_stackable_with_hash(:representations)[Object]).to eq(klass)
     end
   end
 
@@ -211,7 +211,7 @@ describe Grape::API do
     end
 
     %w(group resource resources segment).each do |als|
-      it '`.#{als}` is an alias' do
+      it "`.#{als}` is an alias" do
         inner_namespace = nil
         subject.send(als, :awesome) do
           inner_namespace = namespace
@@ -235,7 +235,7 @@ describe Grape::API do
       expect(last_response.body).to eq('23')
     end
 
-    it 'should be able to define requirements with a single hash' do
+    it 'defines requirements with a single hash' do
       subject.namespace :users do
         route_param :id, requirements: /[0-9]+/ do
           get do
@@ -249,6 +249,18 @@ describe Grape::API do
       get '/users/23'
       expect(last_response.status).to eq(200)
     end
+
+    context 'with param type definitions' do
+      it 'is used by passing to options' do
+        subject.namespace :route_param do
+          route_param :foo, type: Integer do
+            get { params.to_json }
+          end
+        end
+        get '/route_param/1234'
+        expect(last_response.body).to eq("{\"foo\":1234}")
+      end
+    end
   end
 
   describe '.route' do
@@ -482,7 +494,7 @@ describe Grape::API do
 
     verbs = %w(post get head delete put options patch)
     verbs.each do |verb|
-      it 'allows and properly constrain a #{verb.upcase} method' do
+      it "allows and properly constrain a #{verb.upcase} method" do
         subject.send(verb, '/example') do
           verb
         end
@@ -511,10 +523,28 @@ describe Grape::API do
       end
       put '/example'
       expect(last_response.status).to eql 405
-      expect(last_response.body).to eql ''
+      expect(last_response.body).to eql '405 Not Allowed'
       expect(last_response.headers['X-Custom-Header']).to eql 'foo'
     end
 
+    context 'when format is xml' do
+      it 'returns a 405 for an unsupported method' do
+        subject.format :xml
+        subject.get 'example' do
+          'example'
+        end
+
+        put '/example'
+        expect(last_response.status).to eql 405
+        expect(last_response.body).to eq <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<error>
+  <message>405 Not Allowed</message>
+</error>
+XML
+      end
+    end
+
     specify '405 responses includes an Allow header specifying supported methods' do
       subject.get 'example' do
         'example'
@@ -537,49 +567,26 @@ describe Grape::API do
       expect(last_response.headers['Content-Type']).to eql 'text/plain'
     end
 
-    describe 'adds an OPTIONS route that' do
+    context 'allows HEAD on a GET request that' do
       before do
-        subject.before { header 'X-Custom-Header', 'foo' }
         subject.get 'example' do
           'example'
         end
-        options '/example'
+        subject.route :any, '*path' do
+          error! :not_found, 404
+        end
+        head '/example'
       end
 
-      it 'returns a 204' do
-        expect(last_response.status).to eql 204
+      it 'returns a 200' do
+        expect(last_response.status).to eql 200
       end
 
       it 'has an empty body' do
-        expect(last_response.body).to be_blank
-      end
-
-      it 'has an Allow header' do
-        expect(last_response.headers['Allow']).to eql 'OPTIONS, GET, HEAD'
-      end
-
-      it 'has a X-Custom-Header' do
-        expect(last_response.headers['X-Custom-Header']).to eql 'foo'
-      end
-
-      it 'has no Content-Type' do
-        expect(last_response.content_type).to be_nil
-      end
-
-      it 'has no Content-Length' do
-        expect(last_response.content_length).to be_nil
+        expect(last_response.body).to eql ''
       end
     end
 
-    it 'allows HEAD on a GET request' do
-      subject.get 'example' do
-        'example'
-      end
-      head '/example'
-      expect(last_response.status).to eql 200
-      expect(last_response.body).to eql ''
-    end
-
     it 'overwrites the default HEAD request' do
       subject.head 'example' do
         error! 'nothing to see here', 400
@@ -618,9 +625,16 @@ describe Grape::API do
         'example'
       end
     end
-    it 'options does not exist' do
+
+    it 'does not create an OPTIONS route' do
+      options '/example'
+      expect(last_response.status).to eql 405
+    end
+
+    it 'does not include OPTIONS in Allow header' do
       options '/example'
       expect(last_response.status).to eql 405
+      expect(last_response.headers['Allow']).to eql 'GET, HEAD'
     end
   end
 
@@ -870,6 +884,22 @@ describe Grape::API do
       expect(last_response.headers['Content-Type']).to eql 'application/xml'
     end
 
+    it 'includes extension in format' do
+      subject.get(':id') { params[:format] }
+
+      get '/baz.bar'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq 'bar'
+    end
+
+    it 'does not include extension in id' do
+      subject.format :json
+      subject.get(':id') { params }
+
+      get '/baz.bar'
+      expect(last_response.status).to eq 404
+    end
+
     context 'with a custom content_type' do
       before do
         subject.content_type :custom, 'application/custom'
@@ -896,7 +926,7 @@ describe Grape::API do
           filename = params[:file][:filename]
           content_type MIME::Types.type_for(filename)[0].to_s
           env['api.format'] = :binary # there's no formatter for :binary, data will be returned "as is"
-          header 'Content-Disposition', "attachment; filename*=UTF-8''#{URI.escape(filename)}"
+          header 'Content-Disposition', "attachment; filename*=UTF-8''#{CGI.escape(filename)}"
           params[:file][:tempfile].read
         end
       end
@@ -1147,11 +1177,7 @@ describe Grape::API do
     it 'defaults to a standard logger log format' do
       t = Time.at(100)
       allow(Time).to receive(:now).and_return(t)
-      if ActiveSupport::VERSION::MAJOR >= 4
-        expect(subject.io).to receive(:write).with("I, [#{Logger::Formatter.new.send(:format_datetime, t)}\##{Process.pid}]  INFO -- : this will be logged\n")
-      else
-        expect(subject.io).to receive(:write).with("this will be logged\n")
-      end
+      expect(subject.io).to receive(:write).with("I, [#{Logger::Formatter.new.send(:format_datetime, t)}\##{Process.pid}]  INFO -- : this will be logged\n")
       subject.logger.info 'this will be logged'
     end
   end
@@ -1293,7 +1319,21 @@ describe Grape::API do
       subject.get '/exception' do
         fail 'rain!'
       end
-      expect { get '/exception' }.to raise_error
+      expect { get '/exception' }.to raise_error(RuntimeError, 'rain!')
+    end
+
+    it 'uses custom helpers defined by using #helpers method' do
+      subject.helpers do
+        def custom_error!(name)
+          error! "hello #{name}"
+        end
+      end
+      subject.rescue_from(ArgumentError) { custom_error! :bob }
+      subject.get '/custom_error' do
+        fail ArgumentError
+      end
+      get '/custom_error'
+      expect(last_response.body).to eq 'hello bob'
     end
 
     it 'rescues all errors if rescue_from :all is called' do
@@ -1326,7 +1366,7 @@ describe Grape::API do
       get '/rescued'
       expect(last_response.status).to eql 500
 
-      expect { get '/unrescued' }.to raise_error
+      expect { get '/unrescued' }.to raise_error(RuntimeError, 'beefcake')
     end
 
     context 'CustomError subclass of Grape::Exceptions::Base' do
@@ -1359,7 +1399,7 @@ describe Grape::API do
     it 'can rescue exceptions raised in the formatter' do
       formatter = double(:formatter)
       allow(formatter).to receive(:call) { fail StandardError }
-      allow(Grape::Formatter::Base).to receive(:formatter_for) { formatter }
+      allow(Grape::Formatter).to receive(:formatter_for) { formatter }
 
       subject.rescue_from :all do |_e|
         rack_response('Formatter Error', 500)
@@ -1481,18 +1521,26 @@ describe Grape::API do
     end
   end
 
-  describe '.rescue_from klass, with: method' do
-    it 'rescues an error with the specified message' do
-      def rescue_arg_error
-        Rack::Response.new('rescued with a method', 400)
+  describe '.rescue_from klass, with: :method_name' do
+    it 'rescues an error with the specified method name' do
+      subject.helpers do
+        def rescue_arg_error
+          error!('500 ArgumentError', 500)
+        end
       end
-
-      subject.rescue_from ArgumentError, with: rescue_arg_error
+      subject.rescue_from ArgumentError, with: :rescue_arg_error
       subject.get('/rescue_method') { fail ArgumentError }
 
       get '/rescue_method'
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('rescued with a method')
+      expect(last_response.status).to eq(500)
+      expect(last_response.body).to eq('500 ArgumentError')
+    end
+
+    it 'aborts if the specified method name does not exist' do
+      subject.rescue_from :all, with: :not_exist_method
+      subject.get('/rescue_method') { fail StandardError }
+
+      expect { get '/rescue_method' }.to raise_error(NoMethodError, 'undefined method `not_exist_method\'')
     end
   end
 
@@ -1668,13 +1716,23 @@ describe Grape::API do
       get '/error'
       expect(last_response.body).to eql 'Access Denied'
     end
-    it 'rescues error! and return json' do
-      subject.format :json
-      subject.get '/error' do
-        error!('Access Denied', 401)
+    context 'with json format' do
+      before { subject.format :json }
+
+      it 'rescues error! called with a string and returns json' do
+        subject.get('/error') { error!(:failure, 401) }
+      end
+      it 'rescues error! called with a symbol and returns json' do
+        subject.get('/error') { error!(:failure, 401) }
+      end
+      it 'rescues error! called with a hash and returns json' do
+        subject.get('/error') { error!({ error: :failure }, 401) }
+      end
+
+      after do
+        get '/error'
+        expect(last_response.body).to eql('{"error":"failure"}')
       end
-      get '/error'
-      expect(last_response.body).to eql '{"error":"Access Denied"}'
     end
   end