grape 0.19.2 → 1.0.0

data/lib/grape/validations/types/build_coercer.rb

@@ -20,6 +20,12 @@ module Grape
       # @return [Virtus::Attribute] object to be used
       #   for coercion and type validation
       def self.build_coercer(type, method = nil)
+        cache_instance(type, method) do
+          create_coercer_instance(type, method)
+        end
+      end
+
+      def self.create_coercer_instance(type, method = nil)
         # Accept pre-rolled virtus attributes without interference
         return type if type.is_a? Virtus::Attribute
 
@@ -56,6 +62,27 @@ module Grape
         # for many common ruby types.
         Virtus::Attribute.build(conversion_type, converter_options)
       end
+
+      def self.cache_instance(type, method, &_block)
+        key = cache_key(type, method)
+
+        return @__cache[key] if @__cache.key?(key)
+
+        instance = yield
+
+        @__cache_write_lock.synchronize do
+          @__cache[key] = instance
+        end
+
+        instance
+      end
+
+      def self.cache_key(type, method)
+        [type, method].compact.map(&:to_s).join('_')
+      end
+
+      instance_variable_set(:@__cache,            {})
+      instance_variable_set(:@__cache_write_lock, Mutex.new)
     end
   end
 end

data/lib/grape/validations/types/custom_type_coercer.rb

@@ -147,7 +147,7 @@ module Grape
         # Enforce symbolized keys for complex types
         # by wrapping the coercion method such that
         # any Hash objects in the immediate heirarchy
-        # are passed through +Hashie.symbolize_keys!+.
+        # have their keys recursively symbolized.
         # This helps common libs such as JSON to work easily.
         #
         # @param type see #new
@@ -161,8 +161,8 @@ module Grape
           if type == Array || type == Set
             lambda do |val|
               method.call(val).tap do |new_value|
-                new_value.each do |item|
-                  Hashie.symbolize_keys!(item) if item.is_a? Hash
+                new_value.map do |item|
+                  item.is_a?(Hash) ? symbolize_keys(item) : item
                 end
               end
             end
@@ -170,7 +170,7 @@ module Grape
           # Hash objects are processed directly
           elsif type == Hash
             lambda do |val|
-              Hashie.symbolize_keys! method.call(val)
+              symbolize_keys method.call(val)
             end
 
           # Simple types are not processed.
@@ -179,6 +179,20 @@ module Grape
             method
           end
         end
+
+        def symbolize_keys!(hash)
+          hash.each_key do |key|
+            hash[key.to_sym] = hash.delete(key) if key.respond_to?(:to_sym)
+          end
+          hash
+        end
+
+        def symbolize_keys(hash)
+          hash.inject({}) do |new_hash, (key, value)|
+            new_key = key.respond_to?(:to_sym) ? key.to_sym : key
+            new_hash.merge!(new_key => value)
+          end
+        end
       end
     end
   end

data/lib/grape/validations/types/file.rb

@@ -17,10 +17,9 @@ module Grape
 
         def value_coerced?(value)
           # Rack::Request creates a Hash with filename,
-          # content type and an IO object. Grape wraps that
-          # using hashie for convenience. Do a bit of basic
+          # content type and an IO object. Do a bit of basic
           # duck-typing.
-          value.is_a?(Hashie::Mash) && value.key?(:tempfile)
+          value.is_a?(::Hash) && value.key?(:tempfile)
         end
       end
     end

data/lib/grape/validations/validator_factory.rb

@@ -0,0 +1,18 @@
+module Grape
+  module Validations
+    class ValidatorFactory
+      def initialize(**options)
+        @validator_class = options.delete(:validator_class)
+        @options         = options
+      end
+
+      def create_validator
+        @validator_class.new(@options[:attributes],
+                             @options[:options],
+                             @options[:required],
+                             @options[:params_scope],
+                             @options[:opts])
+      end
+    end
+  end
+end

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

@@ -20,7 +20,6 @@ module Grape
       end
 
       # Validates a given request.
-      # @note This method must be thread-safe.
       # @note Override #validate! unless you need to access the entire request.
       # @param request [Grape::Request] the request currently being handled
       # @raise [Grape::Exceptions::Validation] if validation failed
@@ -31,8 +30,7 @@ module Grape
       end
 
       # Validates a given parameter hash.
-      # @note This method must be thread-safe.
-      # @note Override #validate iff you need to access the entire request.
+      # @note Override #validate if you need to access the entire request.
       # @param params [Hash] parameters to validate
       # @raise [Grape::Exceptions::Validation] if validation failed
       # @return [void]
@@ -41,6 +39,7 @@ module Grape
         array_errors = []
         attributes.each do |resource_params, attr_name|
           next unless @required || (resource_params.respond_to?(:key?) && resource_params.key?(attr_name))
+          next unless @scope.meets_dependency?(resource_params)
 
           begin
             validate_param!(attr_name, resource_params)
@@ -64,8 +63,8 @@ module Grape
       end
 
       def self.inherited(klass)
-        short_name = convert_to_short_name(klass)
-        Validations.register_validator(short_name, klass)
+        return unless klass.name.present?
+        Validations.register_validator(convert_to_short_name(klass), klass)
       end
 
       def message(default_key = nil)

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

@@ -10,6 +10,10 @@ module Grape
         @converter = Types.build_coercer(type, @option[:method])
       end
 
+      def validate(request)
+        super
+      end
+
       def validate_param!(attr_name, params)
         raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:coerce) unless params.is_a? Hash
         new_value = coerce_value(params[attr_name])

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

@@ -0,0 +1,20 @@
+module Grape
+  module Validations
+    class ExceptValuesValidator < Base
+      def initialize(attrs, options, required, scope, opts = {})
+        @except = options.is_a?(Hash) ? options[:value] : options
+        super
+      end
+
+      def validate_param!(attr_name, params)
+        return unless params.respond_to?(:key?) && params.key?(attr_name)
+
+        excepts = @except.is_a?(Proc) ? @except.call : @except
+        return if excepts.nil?
+
+        param_array = params[attr_name].nil? ? [nil] : Array.wrap(params[attr_name])
+        raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:except_values) if param_array.any? { |param| excepts.include?(param) }
+      end
+    end
+  end
+end

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

@@ -6,8 +6,17 @@ module Grape
           @excepts = options[:except]
           @values = options[:value]
           @proc = options[:proc]
+
+          warn '[DEPRECATION] The values validator except option is deprecated. ' \
+               'Use the except validator instead.' if @excepts
+
           raise ArgumentError, 'proc must be a Proc' if @proc && !@proc.is_a?(Proc)
+          warn '[DEPRECATION] The values validator proc option is deprecated. ' \
+               'The lambda expression can now be assigned directly to values.' if @proc
         else
+          @excepts = nil
+          @values = nil
+          @proc = nil
           @values = options
         end
         super
@@ -17,15 +26,13 @@ module Grape
         return unless params.is_a?(Hash)
         return unless params[attr_name] || required_for_root_scope?
 
-        values = @values.is_a?(Proc) ? @values.call : @values
-        excepts = @excepts.is_a?(Proc) ? @excepts.call : @excepts
         param_array = params[attr_name].nil? ? [nil] : Array.wrap(params[attr_name])
 
         raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: except_message \
-          if !excepts.nil? && param_array.any? { |param| excepts.include?(param) }
+          unless check_excepts(param_array)
 
         raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:values) \
-          if !values.nil? && !param_array.all? { |param| values.include?(param) }
+          unless check_values(param_array)
 
         raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message(:values) \
           if @proc && !param_array.all? { |param| @proc.call(param) }
@@ -33,9 +40,22 @@ module Grape
 
       private
 
+      def check_values(param_array)
+        values = @values.is_a?(Proc) && @values.arity.zero? ? @values.call : @values
+        return true if values.nil?
+        return param_array.all? { |param| values.call(param) } if values.is_a? Proc
+        param_array.all? { |param| values.include?(param) }
+      end
+
+      def check_excepts(param_array)
+        excepts = @excepts.is_a?(Proc) ? @excepts.call : @excepts
+        return true if excepts.nil?
+        param_array.none? { |param| excepts.include?(param) }
+      end
+
       def except_message
         options = instance_variable_get(:@option)
-        options_key?(:except_message) ? options[:except_message] : message(:except)
+        options_key?(:except_message) ? options[:except_message] : message(:except_values)
       end
 
       def required_for_root_scope?

data/lib/grape/version.rb

@@ -1,4 +1,4 @@
 module Grape
   # The current version of Grape.
-  VERSION = '0.19.2'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/spec/grape/api/invalid_format_spec.rb

@@ -27,17 +27,17 @@ describe Grape::Endpoint do
     it 'no format' do
       get '/foo'
       expect(last_response.status).to eq 200
-      expect(last_response.body).to eq(MultiJson.dump(id: 'foo', format: nil))
+      expect(last_response.body).to eq(::Grape::Json.dump(id: 'foo', format: nil))
     end
     it 'json format' do
       get '/foo.json'
       expect(last_response.status).to eq 200
-      expect(last_response.body).to eq(MultiJson.dump(id: 'foo', format: 'json'))
+      expect(last_response.body).to eq(::Grape::Json.dump(id: 'foo', format: 'json'))
     end
     it 'invalid format' do
       get '/foo.invalid'
       expect(last_response.status).to eq 200
-      expect(last_response.body).to eq(MultiJson.dump(id: 'foo', format: 'invalid'))
+      expect(last_response.body).to eq(::Grape::Json.dump(id: 'foo', format: 'invalid'))
     end
   end
 end

data/spec/grape/api_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'shared/versioning_examples'
-require 'grape-entity'
 
 describe Grape::API do
   subject { Class.new(Grape::API) }
@@ -444,9 +443,9 @@ describe Grape::API do
             subject.send(verb) do
               env['api.request.body']
             end
-            send verb, '/', MultiJson.dump(object), 'CONTENT_TYPE' => 'application/json'
+            send verb, '/', ::Grape::Json.dump(object), 'CONTENT_TYPE' => 'application/json'
             expect(last_response.status).to eq(verb == :post ? 201 : 200)
-            expect(last_response.body).to eql MultiJson.dump(object)
+            expect(last_response.body).to eql ::Grape::Json.dump(object)
             expect(last_request.params).to eql({})
           end
           it 'stores input in api.request.input' do
@@ -454,9 +453,9 @@ describe Grape::API do
             subject.send(verb) do
               env['api.request.input']
             end
-            send verb, '/', MultiJson.dump(object), 'CONTENT_TYPE' => 'application/json'
+            send verb, '/', ::Grape::Json.dump(object), 'CONTENT_TYPE' => 'application/json'
             expect(last_response.status).to eq(verb == :post ? 201 : 200)
-            expect(last_response.body).to eql MultiJson.dump(object).to_json
+            expect(last_response.body).to eql ::Grape::Json.dump(object).to_json
           end
           context 'chunked transfer encoding' do
             it 'stores input in api.request.input' do
@@ -464,9 +463,9 @@ describe Grape::API do
               subject.send(verb) do
                 env['api.request.input']
               end
-              send verb, '/', MultiJson.dump(object), 'CONTENT_TYPE' => 'application/json', 'HTTP_TRANSFER_ENCODING' => 'chunked', 'CONTENT_LENGTH' => nil
+              send verb, '/', ::Grape::Json.dump(object), 'CONTENT_TYPE' => 'application/json', 'HTTP_TRANSFER_ENCODING' => 'chunked', 'CONTENT_LENGTH' => nil
               expect(last_response.status).to eq(verb == :post ? 201 : 200)
-              expect(last_response.body).to eql MultiJson.dump(object).to_json
+              expect(last_response.body).to eql ::Grape::Json.dump(object).to_json
             end
           end
         end
@@ -2053,7 +2052,7 @@ XML
         raise 'rain!'
       end
       get '/exception'
-      json = MultiJson.load(last_response.body)
+      json = ::Grape::Json.load(last_response.body)
       expect(json['error']).to eql 'rain!'
       expect(json['backtrace'].length).to be > 0
     end
@@ -2225,14 +2224,27 @@ XML
         expect(last_response.body).to eql 'elpmis'
       end
     end
-    context 'multi_xml' do
-      it "doesn't parse yaml" do
-        subject.put :yaml do
-          params[:tag]
+    if Object.const_defined? :MultiXml
+      context 'multi_xml' do
+        it "doesn't parse yaml" do
+          subject.put :yaml do
+            params[:tag]
+          end
+          put '/yaml', '<tag type="symbol">a123</tag>', 'CONTENT_TYPE' => 'application/xml'
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eql 'Disallowed type attribute: "symbol"'
+        end
+      end
+    else
+      context 'default xml parser' do
+        it 'parses symbols' do
+          subject.put :yaml do
+            params[:tag]
+          end
+          put '/yaml', '<tag type="symbol">a123</tag>', 'CONTENT_TYPE' => 'application/xml'
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eql '{"type"=>"symbol", "__content__"=>"a123"}'
         end
-        put '/yaml', '<tag type="symbol">a123</tag>', 'CONTENT_TYPE' => 'application/xml'
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eql 'Disallowed type attribute: "symbol"'
       end
     end
     context 'none parser class' do
@@ -3156,7 +3168,7 @@ XML
     end
     it 'path' do
       get '/endpoint/options'
-      options = MultiJson.load(last_response.body)
+      options = ::Grape::Json.load(last_response.body)
       expect(options['path']).to eq(['/endpoint/options'])
       expect(options['source_location'][0]).to include 'api_spec.rb'
       expect(options['source_location'][1].to_i).to be > 0

data/spec/grape/dsl/helpers_spec.rb

@@ -6,8 +6,12 @@ module Grape
       class Dummy
         include Grape::DSL::Helpers
 
-        def self.mod
-          namespace_stackable(:helpers).first
+        def self.mods
+          namespace_stackable(:helpers)
+        end
+
+        def self.first_mod
+          mods.first
         end
       end
     end
@@ -36,23 +40,38 @@ module Grape
           expect(subject).to receive(:namespace_stackable).with(:helpers).and_call_original
           subject.helpers(&proc)
 
-          expect(subject.mod.instance_methods).to include(:test)
+          expect(subject.first_mod.instance_methods).to include(:test)
         end
 
         it 'uses provided modules' do
           mod = Module.new
 
-          expect(subject).to receive(:namespace_stackable).with(:helpers, kind_of(Grape::DSL::Helpers::BaseHelper)).and_call_original
+          expect(subject).to receive(:namespace_stackable).with(:helpers, kind_of(Grape::DSL::Helpers::BaseHelper)).and_call_original.exactly(2).times
           expect(subject).to receive(:namespace_stackable).with(:helpers).and_call_original
           subject.helpers(mod, &proc)
 
-          expect(subject.mod).to eq mod
+          expect(subject.first_mod).to eq mod
+        end
+
+        it 'uses many provided modules' do
+          mod  = Module.new
+          mod2 = Module.new
+          mod3 = Module.new
+
+          expect(subject).to receive(:namespace_stackable).with(:helpers, kind_of(Grape::DSL::Helpers::BaseHelper)).and_call_original.exactly(4).times
+          expect(subject).to receive(:namespace_stackable).with(:helpers).and_call_original.exactly(3).times
+
+          subject.helpers(mod, mod2, mod3, &proc)
+
+          expect(subject.mods).to include(mod)
+          expect(subject.mods).to include(mod2)
+          expect(subject.mods).to include(mod3)
         end
 
         context 'with an external file' do
           it 'sets Boolean as a Virtus::Attribute::Boolean' do
             subject.helpers BooleanParam
-            expect(subject.mod::Boolean).to eq Virtus::Attribute::Boolean
+            expect(subject.first_mod::Boolean).to eq Virtus::Attribute::Boolean
           end
         end
       end

data/spec/grape/endpoint_spec.rb

@@ -249,6 +249,35 @@ describe Grape::Endpoint do
     end
   end
 
+  describe '#params' do
+    context 'default class' do
+      it 'should be a ActiveSupport::HashWithIndifferentAccess' do
+        subject.get '/foo' do
+          params.class
+        end
+
+        get '/foo'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('ActiveSupport::HashWithIndifferentAccess')
+      end
+    end
+
+    context 'sets a value to params' do
+      it 'params' do
+        subject.params do
+          requires :a, type: String
+        end
+        subject.get '/foo' do
+          params[:a] = 'bar'
+        end
+
+        get '/foo', a: 'foo'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('bar')
+      end
+    end
+  end
+
   describe '#declared' do
     before do
       subject.format :json
@@ -269,6 +298,47 @@ describe Grape::Endpoint do
       end
     end
 
+    context 'when params are not built with default class' do
+      it 'returns an object that corresponds with the params class - hash with indifferent access' do
+        subject.params do
+          build_with Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder
+        end
+        subject.get '/declared' do
+          d = declared(params, include_missing: true)
+          { declared_class: d.class.to_s }
+        end
+
+        get '/declared?first=present'
+        expect(JSON.parse(last_response.body)['declared_class']).to eq('ActiveSupport::HashWithIndifferentAccess')
+      end
+
+      it 'returns an object that corresponds with the params class - hashie mash' do
+        subject.params do
+          build_with Grape::Extensions::Hashie::Mash::ParamBuilder
+        end
+        subject.get '/declared' do
+          d = declared(params, include_missing: true)
+          { declared_class: d.class.to_s }
+        end
+
+        get '/declared?first=present'
+        expect(JSON.parse(last_response.body)['declared_class']).to eq('Hashie::Mash')
+      end
+
+      it 'returns an object that corresponds with the params class - hash' do
+        subject.params do
+          build_with Grape::Extensions::Hash::ParamBuilder
+        end
+        subject.get '/declared' do
+          d = declared(params, include_missing: true)
+          { declared_class: d.class.to_s }
+        end
+
+        get '/declared?first=present'
+        expect(JSON.parse(last_response.body)['declared_class']).to eq('Hash')
+      end
+    end
+
     it 'should show nil for nested params if include_missing is true' do
       subject.get '/declared' do
         declared(params, include_missing: true)
@@ -400,7 +470,7 @@ describe Grape::Endpoint do
         ''
       end
 
-      post '/declared', MultiJson.dump(first: 'one', boolean: false), 'CONTENT_TYPE' => 'application/json'
+      post '/declared', ::Grape::Json.dump(first: 'one', boolean: false), 'CONTENT_TYPE' => 'application/json'
       expect(last_response.status).to eq(201)
     end
 
@@ -415,7 +485,7 @@ describe Grape::Endpoint do
         ''
       end
 
-      post '/declared', MultiJson.dump(first: 'one', second: nil), 'CONTENT_TYPE' => 'application/json'
+      post '/declared', ::Grape::Json.dump(first: 'one', second: nil), 'CONTENT_TYPE' => 'application/json'
       expect(last_response.status).to eq(201)
     end
 
@@ -775,6 +845,7 @@ describe Grape::Endpoint do
             end
           end
         end
+
         it 'parse email param with provided requirements for params' do
           get '/outer/abc@example.com'
           expect(last_response.body).to eq('abc@example.com')
@@ -802,7 +873,7 @@ describe Grape::Endpoint do
       end
 
       it 'converts JSON bodies to params' do
-        post '/request_body', MultiJson.dump(user: 'Bobby T.'), 'CONTENT_TYPE' => 'application/json'
+        post '/request_body', ::Grape::Json.dump(user: 'Bobby T.'), 'CONTENT_TYPE' => 'application/json'
         expect(last_response.body).to eq('Bobby T.')
       end
 
@@ -811,14 +882,26 @@ describe Grape::Endpoint do
         expect(last_response.body).to eq('')
       end
 
-      it 'converts XML bodies to params' do
-        post '/request_body', '<user>Bobby T.</user>', 'CONTENT_TYPE' => 'application/xml'
-        expect(last_response.body).to eq('Bobby T.')
-      end
+      if Object.const_defined? :MultiXml
+        it 'converts XML bodies to params' do
+          post '/request_body', '<user>Bobby T.</user>', 'CONTENT_TYPE' => 'application/xml'
+          expect(last_response.body).to eq('Bobby T.')
+        end
 
-      it 'converts XML bodies to params' do
-        put '/request_body', '<user>Bobby T.</user>', 'CONTENT_TYPE' => 'application/xml'
-        expect(last_response.body).to eq('Bobby T.')
+        it 'converts XML bodies to params' do
+          put '/request_body', '<user>Bobby T.</user>', 'CONTENT_TYPE' => 'application/xml'
+          expect(last_response.body).to eq('Bobby T.')
+        end
+      else
+        it 'converts XML bodies to params' do
+          post '/request_body', '<user>Bobby T.</user>', 'CONTENT_TYPE' => 'application/xml'
+          expect(last_response.body).to eq('{"__content__"=>"Bobby T."}')
+        end
+
+        it 'converts XML bodies to params' do
+          put '/request_body', '<user>Bobby T.</user>', 'CONTENT_TYPE' => 'application/xml'
+          expect(last_response.body).to eq('{"__content__"=>"Bobby T."}')
+        end
       end
 
       it 'does not include parameters not defined by the body' do
@@ -826,7 +909,7 @@ describe Grape::Endpoint do
           error! 400, 'expected nil' if params[:version]
           params[:user]
         end
-        post '/omitted_params', MultiJson.dump(user: 'Bob'), 'CONTENT_TYPE' => 'application/json'
+        post '/omitted_params', ::Grape::Json.dump(user: 'Bob'), 'CONTENT_TYPE' => 'application/json'
         expect(last_response.status).to eq(201)
         expect(last_response.body).to eq('Bob')
       end
@@ -849,7 +932,7 @@ describe Grape::Endpoint do
       subject.put '/request_body' do
         params[:user]
       end
-      put '/request_body', MultiJson.dump(user: 'Bob'), 'CONTENT_TYPE' => 'text/plain'
+      put '/request_body', ::Grape::Json.dump(user: 'Bob'), 'CONTENT_TYPE' => 'text/plain'
 
       expect(last_response.status).to eq(406)
       expect(last_response.body).to eq('{"error":"The requested content-type \'text/plain\' is not supported."}')
@@ -863,7 +946,7 @@ describe Grape::Endpoint do
         subject.post do
           params[:data]
         end
-        post '/', MultiJson.dump(data: { some: 'payload' }), 'CONTENT_TYPE' => 'application/json'
+        post '/', ::Grape::Json.dump(data: { some: 'payload' }), 'CONTENT_TYPE' => 'application/json'
       end
 
       it 'should not response with 406 for same type without params' do
@@ -911,6 +994,21 @@ describe Grape::Endpoint do
         expect(JSON.parse(last_response.body)['params']).to eq '123'
       end
     end
+
+    context 'sets a value to params' do
+      it 'params' do
+        subject.params do
+          requires :a, type: String
+        end
+        subject.get '/foo' do
+          params[:a] = 'bar'
+        end
+
+        get '/foo', a: 'foo'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('bar')
+      end
+    end
   end
 
   describe '#error!' do
@@ -1358,6 +1456,9 @@ describe Grape::Endpoint do
         have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :before_validation }),
+        have_attributes(name: 'endpoint_run_validators.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
+                                                                          validators: [],
+                                                                          request: a_kind_of(Grape::Request) }),
         have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :after_validation }),
@@ -1379,6 +1480,9 @@ describe Grape::Endpoint do
         have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :before_validation }),
+        have_attributes(name: 'endpoint_run_validators.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
+                                                                          validators: [],
+                                                                          request: a_kind_of(Grape::Request) }),
         have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :after_validation }),