grape 0.16.2 → 0.17.0

data/spec/grape/dsl/logger_spec.rb

@@ -18,7 +18,7 @@ module Grape
         end
 
         it 'returns a logger' do
-          expect(subject.logger logger).to eq logger
+          expect(subject.logger(logger)).to eq logger
         end
       end
     end

data/spec/grape/dsl/middleware_spec.rb

@@ -7,23 +7,43 @@ module Grape
         include Grape::DSL::Middleware
       end
     end
+
     describe Middleware do
       subject { Class.new(MiddlewareSpec::Dummy) }
       let(:proc) { ->() {} }
+      let(:foo_middleware) { Class.new }
+      let(:bar_middleware) { Class.new }
 
       describe '.use' do
-        it 'adds a middleware' do
-          expect(subject).to receive(:namespace_stackable).with(:middleware, [:my_middleware, :arg1, proc])
+        it 'adds a middleware with the right operation' do
+          expect(subject).to receive(:namespace_stackable).with(:middleware, [:use, foo_middleware, :arg1, proc])
+
+          subject.use foo_middleware, :arg1, &proc
+        end
+      end
+
+      describe '.insert_before' do
+        it 'adds a middleware with the right operation' do
+          expect(subject).to receive(:namespace_stackable).with(:middleware, [:insert_before, foo_middleware, :arg1, proc])
+
+          subject.insert_before foo_middleware, :arg1, &proc
+        end
+      end
+
+      describe '.insert_after' do
+        it 'adds a middleware with the right operation' do
+          expect(subject).to receive(:namespace_stackable).with(:middleware, [:insert_after, foo_middleware, :arg1, proc])
 
-          subject.use :my_middleware, :arg1, &proc
+          subject.insert_after foo_middleware, :arg1, &proc
         end
       end
 
       describe '.middleware' do
         it 'returns the middleware stack' do
-          subject.use :my_middleware, :arg1, &proc
+          subject.use foo_middleware, :arg1, &proc
+          subject.insert_before bar_middleware, :arg1, :arg2
 
-          expect(subject.middleware).to eq [[:my_middleware, :arg1, proc]]
+          expect(subject.middleware).to eq [[:use, foo_middleware, :arg1, proc], [:insert_before, bar_middleware, :arg1, :arg2]]
         end
       end
     end

data/spec/grape/dsl/request_response_spec.rb

@@ -143,37 +143,51 @@ module Grape
           end
         end
 
+        describe ':grape_exceptions' do
+          it 'sets rescue all to true' do
+            expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true)
+            expect(subject).to receive(:namespace_inheritable).with(:rescue_grape_exceptions, true)
+            subject.rescue_from :grape_exceptions
+          end
+
+          it 'sets rescue_grape_exceptions to true' do
+            expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true)
+            expect(subject).to receive(:namespace_inheritable).with(:rescue_grape_exceptions, true)
+            subject.rescue_from :grape_exceptions
+          end
+        end
+
         describe 'list of exceptions is passed' do
           it 'sets hash of exceptions as rescue handlers' do
-            expect(subject).to receive(:namespace_stackable).with(:rescue_handlers, StandardError => nil)
+            expect(subject).to receive(:namespace_reverse_stackable).with(:rescue_handlers, StandardError => nil)
             expect(subject).to receive(:namespace_stackable).with(:rescue_options, {})
             subject.rescue_from StandardError
           end
 
           it 'rescues only base handlers if rescue_subclasses: false option is passed' do
-            expect(subject).to receive(:namespace_stackable).with(:base_only_rescue_handlers, StandardError => nil)
+            expect(subject).to receive(:namespace_reverse_stackable).with(:base_only_rescue_handlers, StandardError => nil)
             expect(subject).to receive(:namespace_stackable).with(:rescue_options, rescue_subclasses: false)
             subject.rescue_from StandardError, rescue_subclasses: false
           end
 
           it 'sets given proc as rescue handler for each key in hash' do
             rescue_handler_proc = proc {}
-            expect(subject).to receive(:namespace_stackable).with(:rescue_handlers, StandardError => rescue_handler_proc)
+            expect(subject).to receive(:namespace_reverse_stackable).with(:rescue_handlers, StandardError => rescue_handler_proc)
             expect(subject).to receive(:namespace_stackable).with(:rescue_options, {})
             subject.rescue_from StandardError, rescue_handler_proc
           end
 
           it 'sets given block as rescue handler for each key in hash' do
             rescue_handler_proc = proc {}
-            expect(subject).to receive(:namespace_stackable).with(:rescue_handlers, StandardError => rescue_handler_proc)
+            expect(subject).to receive(:namespace_reverse_stackable).with(:rescue_handlers, StandardError => rescue_handler_proc)
             expect(subject).to receive(:namespace_stackable).with(:rescue_options, {})
             subject.rescue_from StandardError, &rescue_handler_proc
           end
 
           it 'sets a rescue handler declared through :with option for each key in hash' do
             with_block = -> { 'hello' }
-            expect(subject).to receive(:namespace_stackable).with(:rescue_handlers, StandardError => an_instance_of(Proc))
-            expect(subject).to receive(:namespace_stackable).with(:rescue_options, with: with_block)
+            expect(subject).to receive(:namespace_reverse_stackable).with(:rescue_handlers, StandardError => an_instance_of(Proc))
+            expect(subject).to receive(:namespace_stackable).with(:rescue_options, {})
             subject.rescue_from StandardError, with: with_block
           end
         end

data/spec/grape/dsl/validations_spec.rb

@@ -51,7 +51,7 @@ module Grape
         end
 
         it 'evaluates block' do
-          expect { subject.params { fail 'foo' } }.to raise_error RuntimeError, 'foo'
+          expect { subject.params { raise 'foo' } }.to raise_error RuntimeError, 'foo'
         end
       end
 

data/spec/grape/endpoint_spec.rb

@@ -466,49 +466,192 @@ describe Grape::Endpoint do
   describe '#declared; call from child namespace' do
     before do
       subject.format :json
-      subject.namespace :something do
+      subject.namespace :parent do
         params do
-          requires :id, type: Integer
+          requires :parent_name, type: String
         end
-        resource ':id' do
+
+        namespace ':parent_name' do
           params do
-            requires :foo
-            optional :bar
+            requires :child_name, type: String
+            requires :child_age, type: Integer
           end
+
+          namespace ':child_name' do
+            params do
+              requires :grandchild_name, type: String
+            end
+
+            get ':grandchild_name' do
+              {
+                'params' => params,
+                'without_parent_namespaces' => declared(params, include_parent_namespaces: false),
+                'with_parent_namespaces' => declared(params, include_parent_namespaces: true)
+              }
+            end
+          end
+        end
+      end
+
+      get '/parent/foo/bar/baz', child_age: 5, extra: 'hello'
+    end
+
+    let(:parsed_response) { JSON.parse(last_response.body, symbolize_names: true) }
+
+    it { expect(last_response.status).to eq 200 }
+
+    context 'with include_parent_namespaces: false' do
+      it 'returns declared parameters only from current namespace' do
+        expect(parsed_response[:without_parent_namespaces]).to eq(
+          grandchild_name: 'baz'
+        )
+      end
+    end
+
+    context 'with include_parent_namespaces: true' do
+      it 'returns declared parameters from every parent namespace' do
+        expect(parsed_response[:with_parent_namespaces]).to eq(
+          parent_name: 'foo',
+          child_name: 'bar',
+          grandchild_name: 'baz',
+          child_age: 5
+        )
+      end
+    end
+
+    context 'without declaration' do
+      it 'returns all requested parameters' do
+        expect(parsed_response[:params]).to eq(
+          parent_name: 'foo',
+          child_name: 'bar',
+          grandchild_name: 'baz',
+          child_age: 5,
+          extra: 'hello'
+        )
+      end
+    end
+  end
+
+  describe '#declared; from a nested mounted endpoint' do
+    before do
+      doubly_mounted = Class.new(Grape::API)
+      doubly_mounted.namespace :more do
+        params do
+          requires :y, type: Integer
+        end
+        route_param :y do
           get do
             {
               params: params,
               declared_params: declared(params)
             }
           end
+        end
+      end
+
+      mounted = Class.new(Grape::API)
+      mounted.namespace :another do
+        params do
+          requires :mount_space, type: Integer
+        end
+        route_param :mount_space do
+          mount doubly_mounted
+        end
+      end
+
+      subject.format :json
+      subject.namespace :something do
+        params do
+          requires :id, type: Integer
+        end
+        resource ':id' do
+          mount mounted
+        end
+      end
+    end
+
+    it 'can access parent attributes' do
+      get '/something/123/another/456/more/789'
+      expect(last_response.status).to eq 200
+      json = JSON.parse(last_response.body, symbolize_names: true)
+
+      # test all three levels of params
+      expect(json[:declared_params][:y]).to eq 789
+      expect(json[:declared_params][:mount_space]).to eq 456
+      expect(json[:declared_params][:id]).to eq 123
+    end
+  end
+
+  describe '#declared; with multiple route_param' do
+    before do
+      mounted = Class.new(Grape::API)
+      mounted.namespace :albums do
+        get do
+          declared(params)
+        end
+      end
+
+      subject.format :json
+      subject.namespace :artists do
+        route_param :id, type: Integer do
+          get do
+            declared(params)
+          end
+
           params do
-            requires :happy
-            optional :days
+            requires :filter, type: String
           end
-          get '/test' do
-            {
-              params: params,
-              declared_params: declared(params, include_parent_namespaces: false)
-            }
+          get :some_route do
+            declared(params)
+          end
+        end
+
+        route_param :artist_id, type: Integer do
+          namespace :compositions do
+            get do
+              declared(params)
+            end
           end
         end
+
+        route_param :compositor_id, type: Integer do
+          mount mounted
+        end
       end
     end
 
-    it 'should include params defined in the parent namespace' do
-      get '/something/123', foo: 'test', extra: 'hello'
-      expect(last_response.status).to eq 200
+    it 'return only :id without :artist_id' do
+      get '/artists/1'
+      json = JSON.parse(last_response.body, symbolize_names: true)
+
+      expect(json.key?(:id)).to be_truthy
+      expect(json.key?(:artist_id)).not_to be_truthy
+    end
+
+    it 'return only :artist_id without :id' do
+      get '/artists/1/compositions'
       json = JSON.parse(last_response.body, symbolize_names: true)
-      expect(json[:params][:id]).to eq 123
-      expect(json[:declared_params].keys).to match_array [:foo, :bar, :id]
+
+      expect(json.key?(:artist_id)).to be_truthy
+      expect(json.key?(:id)).not_to be_truthy
     end
 
-    it 'does not include params defined in the parent namespace with include_parent_namespaces: false' do
-      get '/something/123/test', happy: 'test', extra: 'hello'
-      expect(last_response.status).to eq 200
+    it 'return :filter and :id parameters in declared for second enpoint inside route_param' do
+      get '/artists/1/some_route', filter: 'some_filter'
       json = JSON.parse(last_response.body, symbolize_names: true)
-      expect(json[:params][:id]).to eq 123
-      expect(json[:declared_params].keys).to match_array [:happy, :days]
+
+      expect(json.key?(:filter)).to be_truthy
+      expect(json.key?(:id)).to be_truthy
+      expect(json.key?(:artist_id)).not_to be_truthy
+    end
+
+    it 'return :compositor_id for mounter in route_param' do
+      get '/artists/1/albums'
+      json = JSON.parse(last_response.body, symbolize_names: true)
+
+      expect(json.key?(:compositor_id)).to be_truthy
+      expect(json.key?(:id)).not_to be_truthy
+      expect(json.key?(:artist_id)).not_to be_truthy
     end
   end
 
@@ -577,7 +720,7 @@ describe Grape::Endpoint do
               params[:person_email]
             end
 
-            namespace :inner, requirements: { number: /[0-9]/, person_email: /someone@(.*).com/ }do
+            namespace :inner, requirements: { number: /[0-9]/, person_email: /someone@(.*).com/ } do
               get '/:person_email/test/:number' do
                 params[:person_email] << params[:number]
               end

data/spec/grape/entity_spec.rb

@@ -266,8 +266,6 @@ XML
     end
 
     it 'presents with jsonp utilising Rack::JSONP' do
-      require 'rack/contrib'
-
       # Include JSONP middleware
       subject.use Rack::JSONP
 

data/spec/grape/exceptions/body_parse_errors_spec.rb

@@ -52,6 +52,43 @@ describe Grape::Exceptions::ValidationErrors do
     end
   end
 
+  context 'api with rescue_from :grape_exceptions handler' do
+    subject { Class.new(Grape::API) }
+    before do
+      subject.rescue_from :all do |_e|
+        rack_response 'message was processed', 400
+      end
+      subject.rescue_from :grape_exceptions
+
+      subject.params do
+        requires :beer
+      end
+      subject.post '/beer' do
+        'beer received'
+      end
+    end
+
+    def app
+      subject
+    end
+
+    context 'with content_type json' do
+      it 'returns body parsing error message' do
+        post '/beer', 'test', 'CONTENT_TYPE' => 'application/json'
+        expect(last_response.status).to eq 400
+        expect(last_response.body).to include 'message body does not match declared format'
+      end
+    end
+
+    context 'with content_type xml' do
+      it 'returns body parsing error message' do
+        post '/beer', 'test', 'CONTENT_TYPE' => 'application/xml'
+        expect(last_response.status).to eq 400
+        expect(last_response.body).to include 'message body does not match declared format'
+      end
+    end
+  end
+
   context 'api without a rescue handler' do
     subject { Class.new(Grape::API) }
     before do

data/spec/grape/exceptions/validation_errors_spec.rb

@@ -6,11 +6,11 @@ describe Grape::Exceptions::ValidationErrors do
   let(:validation_error) { OpenStruct.new(params: [validation_message]) }
 
   context 'initialize' do
-    let(:headers) {
+    let(:headers) do
       {
         'A-Header-Key' => 'A-Header-Value'
       }
-    }
+    end
 
     subject do
       described_class.new(errors: [validation_error], headers: headers)
@@ -69,9 +69,9 @@ describe Grape::Exceptions::ValidationErrors do
       get '/exactly_one_of', beer: 'string', wine: 'anotherstring'
       expect(last_response.status).to eq(400)
       expect(JSON.parse(last_response.body)).to eq([
-        'params' => %w(beer wine),
-        'messages' => ['are mutually exclusive']
-      ])
+                                                     'params' => %w(beer wine),
+                                                     'messages' => ['are mutually exclusive']
+                                                   ])
     end
   end
 end

data/spec/grape/exceptions/validation_spec.rb

@@ -4,4 +4,14 @@ describe Grape::Exceptions::Validation do
   it 'fails when params are missing' do
     expect { Grape::Exceptions::Validation.new(message: 'presence') }.to raise_error(RuntimeError, 'Params are missing:')
   end
+  context 'when message is a symbol' do
+    it 'stores message_key' do
+      expect(Grape::Exceptions::Validation.new(params: ['id'], message: :presence).message_key).to eq(:presence)
+    end
+  end
+  context 'when message is a String' do
+    it 'does not store the message_key' do
+      expect(Grape::Exceptions::Validation.new(params: ['id'], message: 'presence').message_key).to eq(nil)
+    end
+  end
 end

data/spec/grape/integration/global_namespace_function_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 def namespace
-  fail
+  raise
 end
 
 describe Grape::API do