grape 0.11.0 → 0.12.0

data/spec/grape/dsl/configuration_spec.rb

@@ -47,7 +47,7 @@ module Grape
                         description: 'Not really needed',
                         required: false
                       }
-              ]
+                     ]
           }
 
           subject.desc 'The description' do
@@ -64,7 +64,7 @@ module Grape
                        description: 'Not really needed',
                        required: false
                      }
-            ]
+                    ]
           end
 
           expect(subject.namespace_setting(:description)).to eq(expected_options)

data/spec/grape/dsl/helpers_spec.rb

@@ -16,7 +16,7 @@ module Grape
     describe Helpers do
       subject { Class.new(HelpersSpec::Dummy) }
       let(:proc) do
-        ->(*) do
+        lambda do |*|
           def test
             :test
           end

data/spec/grape/dsl/inside_route_spec.rb

@@ -107,6 +107,25 @@ module Grape
           subject.status 501
           expect(subject.status).to eq 501
         end
+
+        it 'accepts symbol for status' do
+          subject.status :see_other
+          expect(subject.status).to eq 303
+        end
+
+        it 'raises error if unknow symbol is passed' do
+          expect { subject.status :foo_bar }
+            .to raise_error(ArgumentError, 'Status code :foo_bar is invalid.')
+        end
+
+        it 'accepts unknown Fixnum status codes' do
+          expect { subject.status 210 }.to_not raise_error
+        end
+
+        it 'raises error if status is not a fixnum or symbol' do
+          expect { subject.status Object.new }
+            .to raise_error(ArgumentError, 'Status code must be Fixnum or Symbol.')
+        end
       end
 
       describe '#header' do
@@ -176,6 +195,22 @@ module Grape
         end
       end
 
+      describe '#file' do
+        describe 'set' do
+          before do
+            subject.file 'file'
+          end
+
+          it 'returns value' do
+            expect(subject.file).to eq 'file'
+          end
+        end
+
+        it 'returns default' do
+          expect(subject.file).to be nil
+        end
+      end
+
       describe '#route' do
         before do
           subject.env['rack.routing_args'] = {}
@@ -220,30 +255,51 @@ module Grape
           end
         end
 
-        describe 'with' do
-          describe 'multiple entities' do
-            let(:entity_mock1) do
-              entity_mock1 = Object.new
-              allow(entity_mock1).to receive(:represent).and_return(dummy1: 'dummy1')
-              entity_mock1
+        describe 'multiple entities' do
+          let(:entity_mock1) do
+            entity_mock1 = Object.new
+            allow(entity_mock1).to receive(:represent).and_return(dummy1: 'dummy1')
+            entity_mock1
+          end
+
+          let(:entity_mock2) do
+            entity_mock2 = Object.new
+            allow(entity_mock2).to receive(:represent).and_return(dummy2: 'dummy2')
+            entity_mock2
+          end
+
+          describe 'instance' do
+            before do
+              subject.present 'dummy1', with: entity_mock1
+              subject.present 'dummy2', with: entity_mock2
             end
 
-            let(:entity_mock2) do
-              entity_mock2 = Object.new
-              allow(entity_mock2).to receive(:represent).and_return(dummy2: 'dummy2')
-              entity_mock2
+            it 'presents both dummy objects' do
+              expect(subject.body[:dummy1]).to eq 'dummy1'
+              expect(subject.body[:dummy2]).to eq 'dummy2'
             end
+          end
+        end
 
-            describe 'instance' do
-              before do
-                subject.present 'dummy1', with: entity_mock1
-                subject.present 'dummy2', with: entity_mock2
-              end
+        describe 'non mergeable entity' do
+          let(:entity_mock1) do
+            entity_mock1 = Object.new
+            allow(entity_mock1).to receive(:represent).and_return(dummy1: 'dummy1')
+            entity_mock1
+          end
 
-              it 'presents both dummy objects' do
-                expect(subject.body[:dummy1]).to eq 'dummy1'
-                expect(subject.body[:dummy2]).to eq 'dummy2'
-              end
+          let(:entity_mock2) do
+            entity_mock2 = Object.new
+            allow(entity_mock2).to receive(:represent).and_return('not a hash')
+            entity_mock2
+          end
+
+          describe 'instance' do
+            it 'fails' do
+              subject.present 'dummy1', with: entity_mock1
+              expect do
+                subject.present 'dummy2', with: entity_mock2
+              end.to raise_error ArgumentError, 'Representation of type String cannot be merged.'
             end
           end
         end

data/spec/grape/dsl/parameters_spec.rb

@@ -5,6 +5,7 @@ module Grape
     module ParametersSpec
       class Dummy
         include Grape::DSL::Parameters
+        attr_accessor :api, :element, :parent
 
         def validate_attributes(*args)
           @validate_attributes = *args
@@ -41,16 +42,36 @@ module Grape
     describe Parameters do
       subject { ParametersSpec::Dummy.new }
 
-      xdescribe '#use' do
-        it 'does some thing'
+      describe '#use' do
+        before do
+          allow_message_expectations_on_nil
+          allow(subject.api).to receive(:namespace_stackable).with(:named_params)
+        end
+        let(:options) { { option: 'value' } }
+        let(:named_params) { { params_group: proc {} } }
+
+        it 'calls processes associated with named params' do
+          allow(Grape::DSL::Configuration).to receive(:stacked_hash_to_hash).and_return(named_params)
+          expect(subject).to receive(:instance_exec).with(options).and_yield
+          subject.use :params_group, options
+        end
+
+        it 'raises error when non-existent named param is called' do
+          allow(Grape::DSL::Configuration).to receive(:stacked_hash_to_hash).and_return({})
+          expect { subject.use :params_group }.to raise_error('Params :params_group not found!')
+        end
       end
 
-      xdescribe '#use_scope' do
-        it 'does some thing'
+      describe '#use_scope' do
+        it 'is alias to #use' do
+          expect(subject.method(:use_scope)).to eq subject.method(:use)
+        end
       end
 
-      xdescribe '#includes' do
-        it 'does some thing'
+      describe '#includes' do
+        it 'is alias to #use' do
+          expect(subject.method(:includes)).to eq subject.method(:use)
+        end
       end
 
       describe '#requires' do
@@ -103,12 +124,40 @@ module Grape
         end
       end
 
-      xdescribe '#group' do
-        it 'does some thing'
+      describe '#group' do
+        it 'is alias to #requires' do
+          expect(subject.method(:group)).to eq subject.method(:requires)
+        end
       end
 
-      xdescribe '#params' do
-        it 'does some thing'
+      describe '#params' do
+        it 'inherits params from parent' do
+          parent_params = { foo: 'bar' }
+          subject.parent = Object.new
+          allow(subject.parent).to receive(:params).and_return(parent_params)
+          expect(subject.params({})).to eq parent_params
+        end
+
+        describe 'when params argument is an array of hashes' do
+          it 'returns values of each hash for @element key' do
+            subject.element = :foo
+            expect(subject.params([{ foo: 'bar' }, { foo: 'baz' }])).to eq(%w(bar baz))
+          end
+        end
+
+        describe 'when params argument is a hash' do
+          it 'returns value for @element key' do
+            subject.element = :foo
+            expect(subject.params(foo: 'bar')).to eq('bar')
+          end
+        end
+
+        describe 'when params argument is not a array or a hash' do
+          it 'returns empty hash' do
+            subject.element = Object.new
+            expect(subject.params(Object.new)).to eq({})
+          end
+        end
       end
     end
   end

data/spec/grape/dsl/request_response_spec.rb

@@ -101,8 +101,68 @@ module Grape
         end
       end
 
-      xdescribe '.rescue_from' do
-        it 'does some thing'
+      describe '.rescue_from' do
+        describe ':all' 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(:all_rescue_handler, nil)
+            subject.rescue_from :all
+          end
+
+          it 'sets given proc as rescue handler' do
+            rescue_handler_proc = proc {}
+            expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true)
+            expect(subject).to receive(:namespace_inheritable).with(:all_rescue_handler, rescue_handler_proc)
+            subject.rescue_from :all, rescue_handler_proc
+          end
+
+          it 'sets given block as rescue handler' do
+            rescue_handler_proc = proc {}
+            expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true)
+            expect(subject).to receive(:namespace_inheritable).with(:all_rescue_handler, rescue_handler_proc)
+            subject.rescue_from :all, &rescue_handler_proc
+          end
+
+          it 'sets a rescue handler declared through :with option' do
+            expect(subject).to receive(:namespace_inheritable).with(:rescue_all, true)
+            expect(subject).to receive(:namespace_inheritable).with(:all_rescue_handler, an_instance_of(Proc))
+            subject.rescue_from :all, with: 'ExampleHandler'
+          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_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_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_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_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
+            expect(subject).to receive(:namespace_stackable).with(:rescue_handlers, StandardError => an_instance_of(Proc))
+            expect(subject).to receive(:namespace_stackable).with(:rescue_options, with: 'ExampleHandler')
+            subject.rescue_from StandardError, with: 'ExampleHandler'
+          end
+        end
       end
 
       describe '.represent' do

data/spec/grape/dsl/routing_spec.rb

@@ -59,13 +59,53 @@ module Grape
 
           expect(subject.inheritable_setting.to_hash[:namespace]).to eq({})
           expect(subject.inheritable_setting.to_hash[:namespace_inheritable]).to eq({})
-          expect(app1.inheritable_setting.to_hash[:namespace_stackable]).to eq(:mount_path => ['/app1'])
+          expect(app1.inheritable_setting.to_hash[:namespace_stackable]).to eq(mount_path: ['/app1'])
 
-          expect(app2.inheritable_setting.to_hash[:namespace_stackable]).to eq(:mount_path => ['/app1', '/app2'])
+          expect(app2.inheritable_setting.to_hash[:namespace_stackable]).to eq(mount_path: ['/app1', '/app2'])
         end
       end
-      xdescribe '.route' do
-        it 'does some thing'
+
+      describe '.route' do
+        before do
+          allow(subject).to receive(:endpoints).and_return([])
+          allow(subject).to receive(:route_end)
+          allow(subject).to receive(:reset_validations!)
+        end
+
+        it 'marks end of the route' do
+          expect(subject).to receive(:route_end)
+          subject.route(:any)
+        end
+
+        it 'resets validations' do
+          expect(subject).to receive(:reset_validations!)
+          subject.route(:any)
+        end
+
+        it 'defines a new endpoint' do
+          expect { subject.route(:any) }
+            .to change { subject.endpoints.count }.from(0).to(1)
+        end
+
+        it 'does not duplicate identical endpoints' do
+          subject.route(:any)
+          expect { subject.route(:any) }
+            .to_not change(subject.endpoints, :count)
+        end
+
+        it 'generates correct endpoint options' do
+          allow(subject).to receive(:route_setting).with(:description).and_return(fiz: 'baz')
+          allow(Grape::DSL::Configuration).to receive(:stacked_hash_to_hash).and_return(nuz: 'naz')
+
+          expect(Grape::Endpoint).to receive(:new) do |_inheritable_setting, endpoint_options|
+            expect(endpoint_options[:method]).to eq :get
+            expect(endpoint_options[:path]).to eq '/foo'
+            expect(endpoint_options[:for]).to eq subject
+            expect(endpoint_options[:route_options]).to eq(foo: 'bar', fiz: 'baz', params: { nuz: 'naz' })
+          end.and_yield
+
+          subject.route(:get, '/foo', { foo: 'bar' }, &proc {})
+        end
       end
 
       describe '.get' do
@@ -117,32 +157,90 @@ module Grape
         end
       end
 
-      xdescribe '.namespace' do
-        it 'does some thing'
+      describe '.namespace' do
+        let(:new_namespace) { Object.new }
+
+        it 'creates a new namespace with given name and options' do
+          expect(subject).to receive(:within_namespace).and_yield
+          expect(subject).to receive(:nest).and_yield
+          expect(Namespace).to receive(:new).with(:foo, foo: 'bar').and_return(new_namespace)
+          expect(subject).to receive(:namespace_stackable).with(:namespace, new_namespace)
+
+          subject.namespace :foo, foo: 'bar', &proc {}
+        end
+
+        it 'calls #joined_space_path on Namespace' do
+          result_of_namspace_stackable = Object.new
+          allow(subject).to receive(:namespace_stackable).and_return(result_of_namspace_stackable)
+          expect(Namespace).to receive(:joined_space_path).with(result_of_namspace_stackable)
+          subject.namespace
+        end
       end
 
-      xdescribe '.group' do
-        it 'does some thing'
+      describe '.group' do
+        it 'is alias to #namespace' do
+          expect(subject.method(:group)).to eq subject.method(:namespace)
+        end
       end
 
-      xdescribe '.resource' do
-        it 'does some thing'
+      describe '.resource' do
+        it 'is alias to #namespace' do
+          expect(subject.method(:resource)).to eq subject.method(:namespace)
+        end
       end
 
-      xdescribe '.resources' do
-        it 'does some thing'
+      describe '.resources' do
+        it 'is alias to #namespace' do
+          expect(subject.method(:resources)).to eq subject.method(:namespace)
+        end
       end
 
-      xdescribe '.segment' do
-        it 'does some thing'
+      describe '.segment' do
+        it 'is alias to #namespace' do
+          expect(subject.method(:segment)).to eq subject.method(:namespace)
+        end
       end
 
-      xdescribe '.routes' do
-        it 'does some thing'
+      describe '.routes' do
+        let(:routes) { Object.new }
+
+        it 'returns value received from #prepare_routes' do
+          expect(subject).to receive(:prepare_routes).and_return(routes)
+          expect(subject.routes).to eq routes
+        end
+
+        context 'when #routes was already called once' do
+          before do
+            allow(subject).to receive(:prepare_routes).and_return(routes)
+            subject.routes
+          end
+          it 'it does not call prepare_routes again' do
+            expect(subject).to_not receive(:prepare_routes)
+            expect(subject.routes).to eq routes
+          end
+        end
       end
 
-      xdescribe '.route_param' do
-        it 'does some thing'
+      describe '.route_param' do
+        it 'calls #namespace with given params' do
+          expect(subject).to receive(:namespace).with(':foo', {}).and_yield
+          subject.route_param('foo', {}, &proc {})
+        end
+
+        let(: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
+          end
+          subject.route_param('foo', options, &proc {})
+        end
+
+        it 'does not modify options parameter' do
+          allow(subject).to receive(:namespace)
+          expect { subject.route_param('foo', options, &proc {}) }
+            .to_not change { options }
+        end
       end
 
       describe '.versions' do