grape 0.13.0 → 0.14.0

data/spec/grape/dsl/configuration_spec.rb

@@ -70,6 +70,19 @@ module Grape
           expect(subject.namespace_setting(:description)).to eq(expected_options)
           expect(subject.route_setting(:description)).to eq(expected_options)
         end
+
+        it 'can be set with options and a block' do
+          expect(subject).to receive(:warn).with('[DEPRECATION] Passing a options hash and a block to `desc` is deprecated. Move all hash options to block.')
+
+          desc_text = 'The description'
+          detail_text = 'more details'
+          options = { message: 'none' }
+          subject.desc desc_text, options do
+            detail detail_text
+          end
+          expect(subject.namespace_setting(:description)).to eq(description: desc_text, detail: detail_text)
+          expect(subject.route_setting(:description)).to eq(description: desc_text, detail: detail_text)
+        end
       end
     end
   end

data/spec/grape/dsl/helpers_spec.rb

@@ -6,13 +6,20 @@ module Grape
       class Dummy
         include Grape::DSL::Helpers
 
-        # rubocop:disable TrivialAccessors
         def self.mod
           namespace_stackable(:helpers).first
         end
-        # rubocop:enable TrivialAccessors
       end
     end
+
+    module BooleanParam
+      extend Grape::API::Helpers
+
+      params :requires_toggle_prm do
+        requires :toggle_prm, type: Boolean
+      end
+    end
+
     describe Helpers do
       subject { Class.new(HelpersSpec::Dummy) }
       let(:proc) do
@@ -41,6 +48,13 @@ module Grape
 
           expect(subject.mod).to eq mod
         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
+          end
+        end
       end
     end
   end

data/spec/grape/dsl/inside_route_spec.rb

@@ -343,8 +343,9 @@ module Grape
       describe '#declared' do
         # see endpoint_spec.rb#declared for spec coverage
 
-        it 'returns an empty hash' do
-          expect(subject.declared({})).to eq({})
+        it 'is not available by default' do
+          expect { subject.declared({}) }.to raise_error(
+            Grape::DSL::InsideRoute::MethodNotYetAvailable)
         end
       end
     end

data/spec/grape/dsl/parameters_spec.rb

@@ -11,31 +11,25 @@ module Grape
           @validate_attributes = *args
         end
 
-        # rubocop:disable TrivialAccessors
         def validate_attributes_reader
           @validate_attributes
         end
-        # rubocop:enable TrivialAccessors
 
         def push_declared_params(*args)
           @push_declared_params = args
         end
 
-        # rubocop:disable TrivialAccessors
         def push_declared_params_reader
           @push_declared_params
         end
-        # rubocop:enable TrivialAccessors
 
         def validates(*args)
           @validates = *args
         end
 
-        # rubocop:disable TrivialAccessors
         def validates_reader
           @validates
         end
-        # rubocop:enable TrivialAccessors
       end
     end
 

data/spec/grape/dsl/routing_spec.rb

@@ -228,7 +228,7 @@ module Grape
         end
 
         let(:regex) { /(.*)/ }
-        let!(:options) {  { requirements: regex } }
+        let!(:options) { { requirements: regex } }
         it 'nests requirements option under param name' do
           expect(subject).to receive(:namespace) do |_param, options|
             expect(options[:requirements][:foo]).to eq regex

data/spec/grape/endpoint_spec.rb

@@ -11,15 +11,15 @@ describe Grape::Endpoint do
     after { Grape::Endpoint.before_each(nil) }
 
     it 'should be settable via block' do
-      block = lambda { |_endpoint| 'noop' }
+      block = ->(_endpoint) { 'noop' }
       Grape::Endpoint.before_each(&block)
-      expect(Grape::Endpoint.before_each).to eq(block)
+      expect(Grape::Endpoint.before_each.first).to eq(block)
     end
 
     it 'should be settable via reference' do
-      block = lambda { |_endpoint| 'noop' }
+      block = ->(_endpoint) { 'noop' }
       Grape::Endpoint.before_each block
-      expect(Grape::Endpoint.before_each).to eq(block)
+      expect(Grape::Endpoint.before_each.first).to eq(block)
     end
 
     it 'should be able to override a helper' do
@@ -36,6 +36,28 @@ describe Grape::Endpoint do
       Grape::Endpoint.before_each(nil)
       expect { get '/' }.to raise_error(NameError)
     end
+
+    it 'should be able to stack helper' do
+      subject.get('/') do
+        authenticate_user!
+        current_user
+      end
+      expect { get '/' }.to raise_error(NameError)
+
+      Grape::Endpoint.before_each do |endpoint|
+        allow(endpoint).to receive(:current_user).and_return('Bob')
+      end
+
+      Grape::Endpoint.before_each do |endpoint|
+        allow(endpoint).to receive(:authenticate_user!).and_return(true)
+      end
+
+      get '/'
+      expect(last_response.body).to eq('Bob')
+
+      Grape::Endpoint.before_each(nil)
+      expect { get '/' }.to raise_error(NameError)
+    end
   end
 
   describe '#initialize' do
@@ -239,6 +261,16 @@ describe Grape::Endpoint do
       end
     end
 
+    it 'does not work in a before filter' do
+      subject.before do
+        declared(params)
+      end
+      subject.get('/declared') { declared(params) }
+
+      expect { get('/declared') }.to raise_error(
+        Grape::DSL::InsideRoute::MethodNotYetAvailable)
+    end
+
     it 'has as many keys as there are declared params' do
       inner_params = nil
       subject.get '/declared' do
@@ -742,7 +774,7 @@ describe Grape::Endpoint do
       get '/hey'
       expect(last_response.status).to eq 302
       expect(last_response.headers['Location']).to eq '/ha'
-      expect(last_response.body).to eq ''
+      expect(last_response.body).to eq 'This resource has been moved temporarily to /ha.'
     end
 
     it 'has status code 303 if it is not get request and it is http 1.1' do
@@ -752,6 +784,7 @@ describe Grape::Endpoint do
       post '/hey', {}, 'HTTP_VERSION' => 'HTTP/1.1'
       expect(last_response.status).to eq 303
       expect(last_response.headers['Location']).to eq '/ha'
+      expect(last_response.body).to eq 'An alternate resource is located at /ha.'
     end
 
     it 'support permanent redirect' do
@@ -761,7 +794,15 @@ describe Grape::Endpoint do
       get '/hey'
       expect(last_response.status).to eq 301
       expect(last_response.headers['Location']).to eq '/ha'
-      expect(last_response.body).to eq ''
+      expect(last_response.body).to eq 'This resource has been moved permanently to /ha.'
+    end
+
+    it 'allows for an optional redirect body override' do
+      subject.get('/hey') do
+        redirect '/ha', body: 'test body'
+      end
+      get '/hey'
+      expect(last_response.body).to eq 'test body'
     end
   end
 
@@ -987,38 +1028,38 @@ describe Grape::Endpoint do
 
       # In order that the events finalized (time each block ended)
       expect(@events).to contain_exactly(
-        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: a_collection_containing_exactly(an_instance_of(Proc)),
                                                                        type: :before }),
-        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :before_validation }),
-        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :after_validation }),
-        have_attributes(name: 'endpoint_render.grape',      payload: { endpoint: an_instance_of(Grape::Endpoint) }),
-        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_render.grape',      payload: { endpoint: a_kind_of(Grape::Endpoint) }),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :after }),
-        have_attributes(name: 'endpoint_run.grape',         payload: { endpoint: an_instance_of(Grape::Endpoint),
-                                                                       env: an_instance_of(Hash) })
+        have_attributes(name: 'endpoint_run.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
+                                                               env: an_instance_of(Hash) })
       )
 
       # In order that events were initialized
       expect(@events.sort_by(&:time)).to contain_exactly(
-        have_attributes(name: 'endpoint_run.grape',         payload: { endpoint: an_instance_of(Grape::Endpoint),
-                                                                       env: an_instance_of(Hash) }),
-        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_run.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
+                                                               env: an_instance_of(Hash) }),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: a_collection_containing_exactly(an_instance_of(Proc)),
                                                                        type: :before }),
-        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :before_validation }),
-        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :after_validation }),
-        have_attributes(name: 'endpoint_render.grape',      payload: { endpoint: an_instance_of(Grape::Endpoint) }),
-        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+        have_attributes(name: 'endpoint_render.grape',      payload: { endpoint: a_kind_of(Grape::Endpoint) }),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: a_kind_of(Grape::Endpoint),
                                                                        filters: [],
                                                                        type: :after })
       )

data/spec/grape/entity_spec.rb

@@ -45,22 +45,24 @@ describe Grape::Entity do
       entity = Class.new(Grape::Entity)
       allow(entity).to receive(:represent).and_return('Hiya')
 
-      class TestObject
-      end
+      module EntitySpec
+        class TestObject
+        end
 
-      class FakeCollection
-        def first
-          TestObject.new
+        class FakeCollection
+          def first
+            TestObject.new
+          end
         end
       end
 
-      subject.represent TestObject, with: entity
+      subject.represent EntitySpec::TestObject, with: entity
       subject.get '/example' do
-        present [TestObject.new]
+        present [EntitySpec::TestObject.new]
       end
 
       subject.get '/example2' do
-        present FakeCollection.new
+        present EntitySpec::FakeCollection.new
       end
 
       get '/example'

data/spec/grape/exceptions/invalid_accept_header_spec.rb

@@ -54,13 +54,6 @@ describe Grape::Exceptions::InvalidAcceptHeader do
     end
 
     context 'that receives' do
-      context 'an invalid version in the request' do
-        before do
-          get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v77',
-                           'CONTENT_TYPE' => 'application/json'
-        end
-        it_should_behave_like 'a rescued request'
-      end
       context 'an invalid vendor in the request' do
         before do
           get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99',
@@ -128,13 +121,6 @@ describe Grape::Exceptions::InvalidAcceptHeader do
     end
 
     context 'that receives' do
-      context 'an invalid version in the request' do
-        before do
-          get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v77',
-                           'CONTENT_TYPE' => 'application/json'
-        end
-        it_should_behave_like 'a rescued request'
-      end
       context 'an invalid vendor in the request' do
         before do
           get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.invalidvendor-v99',
@@ -318,7 +304,7 @@ describe Grape::Exceptions::InvalidAcceptHeader do
 
     context 'that receives' do
       context 'an invalid version in the request' do
-        before { get '/beer', {},  'HTTP_ACCEPT' => 'application/vnd.vendorname-v77' }
+        before { get '/beer', {}, 'HTTP_ACCEPT' => 'application/vnd.vendorname-v77' }
         it_should_behave_like 'a cascaded request'
       end
       context 'an invalid vendor in the request' do

data/spec/grape/integration/rack_spec.rb

@@ -20,8 +20,9 @@ describe Rack do
       env = Rack::MockRequest.env_for('/', options)
 
       unless RUBY_PLATFORM == 'java'
-        major, minor, release = Rack.release.split('.').map(&:to_i)
-        pending 'Rack 1.5.3 or 1.6.1 required' unless major >= 1 && ((minor == 5 && release >= 3) || (minor >= 6))
+        major, minor, patch = Rack.release.split('.').map(&:to_i)
+        patch ||= 0 # rack <= 1.5.2 does not specify patch version
+        pending 'Rack 1.5.3 or 1.6.1 required' unless major >= 1 && ((minor == 5 && patch >= 3) || (minor >= 6))
       end
 
       expect(JSON.parse(app.call(env)[2].body.first)['params_keys']).to match_array('test')

data/spec/grape/middleware/base_spec.rb

@@ -82,18 +82,20 @@ describe Grape::Middleware::Base do
     end
 
     context 'defaults' do
-      class ExampleWare < Grape::Middleware::Base
-        def default_options
-          { monkey: true }
+      module BaseSpec
+        class ExampleWare < Grape::Middleware::Base
+          def default_options
+            { monkey: true }
+          end
         end
       end
 
       it 'persists the default options' do
-        expect(ExampleWare.new(blank_app).options[:monkey]).to be true
+        expect(BaseSpec::ExampleWare.new(blank_app).options[:monkey]).to be true
       end
 
       it 'overrides default options when provided' do
-        expect(ExampleWare.new(blank_app, monkey: false).options[:monkey]).to be false
+        expect(BaseSpec::ExampleWare.new(blank_app, monkey: false).options[:monkey]).to be false
       end
     end
   end

data/spec/grape/middleware/error_spec.rb

@@ -11,14 +11,15 @@ describe Grape::Middleware::Error do
         'static text'
       end
     end
-  end
-  class ErrApp
-    class << self
-      attr_accessor :error
-      attr_accessor :format
 
-      def call(_env)
-        throw :error, error
+    class ErrApp
+      class << self
+        attr_accessor :error
+        attr_accessor :format
+
+        def call(_env)
+          throw :error, error
+        end
       end
     end
   end
@@ -28,32 +29,32 @@ describe Grape::Middleware::Error do
     Rack::Builder.app do
       use Spec::Support::EndpointFaker
       use Grape::Middleware::Error, opts
-      run ErrApp
+      run ErrorSpec::ErrApp
     end
   end
 
-  let(:options) {  { default_message: 'Aww, hamburgers.' } }
+  let(:options) { { default_message: 'Aww, hamburgers.' } }
 
   it 'sets the status code appropriately' do
-    ErrApp.error = { status: 410 }
+    ErrorSpec::ErrApp.error = { status: 410 }
     get '/'
     expect(last_response.status).to eq(410)
   end
 
   it 'sets the error message appropriately' do
-    ErrApp.error = { message: 'Awesome stuff.' }
+    ErrorSpec::ErrApp.error = { message: 'Awesome stuff.' }
     get '/'
     expect(last_response.body).to eq('Awesome stuff.')
   end
 
   it 'defaults to a 500 status' do
-    ErrApp.error = {}
+    ErrorSpec::ErrApp.error = {}
     get '/'
     expect(last_response.status).to eq(500)
   end
 
   it 'has a default message' do
-    ErrApp.error = {}
+    ErrorSpec::ErrApp.error = {}
     get '/'
     expect(last_response.body).to eq('Aww, hamburgers.')
   end
@@ -61,14 +62,14 @@ describe Grape::Middleware::Error do
   context 'with http code' do
     let(:options) {  { default_message: 'Aww, hamburgers.' } }
     it 'adds the status code if wanted' do
-      ErrApp.error = { message: { code: 200 } }
+      ErrorSpec::ErrApp.error = { message: { code: 200 } }
       get '/'
 
       expect(last_response.body).to eq({ code: 200 }.to_json)
     end
 
     it 'presents an error message' do
-      ErrApp.error = { message: { code: 200, with: ErrorSpec::ErrorEntity } }
+      ErrorSpec::ErrApp.error = { message: { code: 200, with: ErrorSpec::ErrorEntity } }
       get '/'
 
       expect(last_response.body).to eq({ code: 200, static: 'static text' }.to_json)