grape 1.5.1 → 1.6.1

data/spec/grape/dsl/callbacks_spec.rb

@@ -12,7 +12,8 @@ module Grape
 
     describe Callbacks do
       subject { Class.new(CallbacksSpec::Dummy) }
-      let(:proc) { ->() {} }
+
+      let(:proc) { -> {} }
 
       describe '.before' do
         it 'adds a block to "before"' do

data/spec/grape/dsl/headers_spec.rb

@@ -12,21 +12,51 @@ module Grape
     describe Headers do
       subject { HeadersSpec::Dummy.new }
 
-      describe '#header' do
-        describe 'set' do
+      let(:header_data) do
+        { 'First Key' => 'First Value',
+          'Second Key' => 'Second Value' }
+      end
+
+      context 'when headers are set' do
+        describe '#header' do
           before do
-            subject.header 'Name', 'Value'
+            header_data.each { |k, v| subject.header(k, v) }
+          end
+
+          describe 'get' do
+            it 'returns a specifc value' do
+              expect(subject.header['First Key']).to eq 'First Value'
+              expect(subject.header['Second Key']).to eq 'Second Value'
+            end
+
+            it 'returns all set headers' do
+              expect(subject.header).to eq header_data
+              expect(subject.headers).to eq header_data
+            end
           end
 
-          it 'returns value' do
-            expect(subject.header['Name']).to eq 'Value'
-            expect(subject.header('Name')).to eq 'Value'
+          describe 'set' do
+            it 'returns value' do
+              expect(subject.header('Third Key', 'Third Value'))
+              expect(subject.header['Third Key']).to eq 'Third Value'
+            end
+          end
+
+          describe 'delete' do
+            it 'deletes a header key-value pair' do
+              expect(subject.header('First Key')).to eq header_data['First Key']
+              expect(subject.header).not_to have_key('First Key')
+            end
           end
         end
+      end
 
-        it 'returns nil' do
-          expect(subject.header['Name']).to be nil
-          expect(subject.header('Name')).to be nil
+      context 'when no headers are set' do
+        describe '#header' do
+          it 'returns nil' do
+            expect(subject.header['First Key']).to be nil
+            expect(subject.header('First Key')).to be nil
+          end
         end
       end
     end

data/spec/grape/dsl/helpers_spec.rb

@@ -34,6 +34,7 @@ module Grape
 
     describe Helpers do
       subject { Class.new(HelpersSpec::Dummy) }
+
       let(:proc) do
         lambda do |*|
           def test
@@ -54,7 +55,7 @@ module Grape
         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.exactly(2).times
+          expect(subject).to receive(:namespace_stackable).with(:helpers, kind_of(Grape::DSL::Helpers::BaseHelper)).and_call_original.twice
           expect(subject).to receive(:namespace_stackable).with(:helpers).and_call_original
           subject.helpers(mod, &proc)
 
@@ -92,7 +93,7 @@ module Grape
                   use :requires_toggle_prm
                 end
               end
-            end.to_not raise_exception
+            end.not_to raise_exception
           end
         end
       end

data/spec/grape/dsl/inside_route_spec.rb

@@ -43,6 +43,7 @@ describe Grape::Endpoint do
       before do
         catch(:error) { subject.error! 'Not Found', 404 }
       end
+
       it 'sets status' do
         expect(subject.status).to eq 404
       end
@@ -53,6 +54,7 @@ describe Grape::Endpoint do
         subject.namespace_inheritable(:default_error_status, 500)
         catch(:error) { subject.error! 'Unknown' }
       end
+
       it 'sets status to default_error_status' do
         expect(subject.status).to eq 500
       end
@@ -136,7 +138,7 @@ describe Grape::Endpoint do
     end
 
     it 'accepts unknown Integer status codes' do
-      expect { subject.status 210 }.to_not raise_error
+      expect { subject.status 210 }.not_to raise_error
     end
 
     it 'raises error if status is not a integer or symbol' do
@@ -273,7 +275,7 @@ describe Grape::Endpoint do
         end
 
         it 'sends no deprecation warnings' do
-          expect(subject).to_not receive(:warn)
+          expect(subject).not_to receive(:warn)
 
           subject.sendfile file_path
         end
@@ -334,7 +336,7 @@ describe Grape::Endpoint do
         end
 
         it 'emits no deprecation warnings' do
-          expect(subject).to_not receive(:warn)
+          expect(subject).not_to receive(:warn)
 
           subject.stream file_path
         end
@@ -384,7 +386,7 @@ describe Grape::Endpoint do
         end
 
         it 'emits no deprecation warnings' do
-          expect(subject).to_not receive(:warn)
+          expect(subject).not_to receive(:warn)
 
           subject.stream stream_object
         end

data/spec/grape/dsl/logger_spec.rb

@@ -2,27 +2,25 @@
 
 require 'spec_helper'
 
-module Grape
-  module DSL
-    module LoggerSpec
-      class Dummy
-        extend Grape::DSL::Logger
-      end
+describe Grape::DSL::Logger do
+  subject { Class.new(dummy_logger) }
+
+  let(:dummy_logger) do
+    Class.new do
+      extend Grape::DSL::Logger
     end
-    describe Logger do
-      subject { Class.new(LoggerSpec::Dummy) }
-      let(:logger) { double(:logger) }
+  end
 
-      describe '.logger' do
-        it 'sets a logger' do
-          subject.logger logger
-          expect(subject.logger).to eq logger
-        end
+  let(:logger) { instance_double(::Logger) }
+
+  describe '.logger' do
+    it 'sets a logger' do
+      subject.logger logger
+      expect(subject.logger).to eq logger
+    end
 
-        it 'returns a logger' do
-          expect(subject.logger(logger)).to eq logger
-        end
-      end
+    it 'returns a logger' do
+      expect(subject.logger(logger)).to eq logger
     end
   end
 end

data/spec/grape/dsl/middleware_spec.rb

@@ -12,7 +12,8 @@ module Grape
 
     describe Middleware do
       subject { Class.new(MiddlewareSpec::Dummy) }
-      let(:proc) { ->() {} }
+
+      let(:proc) { -> {} }
       let(:foo_middleware) { Class.new }
       let(:bar_middleware) { Class.new }
 

data/spec/grape/dsl/parameters_spec.rb

@@ -40,6 +40,7 @@ module Grape
 
         def extract_message_option(attrs)
           return nil unless attrs.is_a?(Array)
+
           opts = attrs.last.is_a?(Hash) ? attrs.pop : {}
           opts.key?(:message) && !opts[:message].nil? ? opts.delete(:message) : nil
         end
@@ -54,6 +55,7 @@ module Grape
           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 {} } }
 

data/spec/grape/dsl/request_response_spec.rb

@@ -20,6 +20,7 @@ module Grape
 
     describe RequestResponse do
       subject { Class.new(RequestResponseSpec::Dummy) }
+
       let(:c_type) { 'application/json' }
       let(:format) { 'txt' }
 

data/spec/grape/dsl/routing_spec.rb

@@ -12,7 +12,8 @@ module Grape
 
     describe Routing do
       subject { Class.new(RoutingSpec::Dummy) }
-      let(:proc) { ->() {} }
+
+      let(:proc) { -> {} }
       let(:options) { { a: :b } }
       let(:path) { '/dummy' }
 
@@ -109,7 +110,7 @@ module Grape
         it 'does not duplicate identical endpoints' do
           subject.route(:any)
           expect { subject.route(:any) }
-            .to_not change(subject.endpoints, :count)
+            .not_to change(subject.endpoints, :count)
         end
 
         it 'generates correct endpoint options' do
@@ -233,21 +234,23 @@ module Grape
             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)
+
+          it 'does not call prepare_routes again' do
+            expect(subject).not_to receive(:prepare_routes)
             expect(subject.routes).to eq routes
           end
         end
       end
 
       describe '.route_param' do
+        let!(:options) { { requirements: regex } }
+        let(:regex) { /(.*)/ }
+
         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
@@ -258,7 +261,7 @@ module Grape
         it 'does not modify options parameter' do
           allow(subject).to receive(:namespace)
           expect { subject.route_param('foo', options, &proc {}) }
-            .to_not change { options }
+            .not_to change { options }
         end
       end
 

data/spec/grape/endpoint/declared_spec.rb

@@ -87,7 +87,7 @@ describe Grape::Endpoint do
       end
     end
 
-    it 'should show nil for nested params if include_missing is true' do
+    it 'shows nil for nested params if include_missing is true' do
       subject.get '/declared' do
         declared(params, include_missing: true)
       end
@@ -97,7 +97,7 @@ describe Grape::Endpoint do
       expect(JSON.parse(last_response.body)['nested']['fourth']).to be_nil
     end
 
-    it 'should show nil for multiple allowed types if include_missing is true' do
+    it 'shows nil for multiple allowed types if include_missing is true' do
       subject.get '/declared' do
         declared(params, include_missing: true)
       end
@@ -568,34 +568,281 @@ describe Grape::Endpoint 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
+      expect(json).to be_key(:id)
+      expect(json).not_to be_key(:artist_id)
     end
 
     it 'return only :artist_id without :id' do
       get '/artists/1/compositions'
       json = JSON.parse(last_response.body, symbolize_names: true)
 
-      expect(json.key?(:artist_id)).to be_truthy
-      expect(json.key?(:id)).not_to be_truthy
+      expect(json).to be_key(:artist_id)
+      expect(json).not_to be_key(:id)
     end
 
     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.key?(:filter)).to be_truthy
-      expect(json.key?(:id)).to be_truthy
-      expect(json.key?(:artist_id)).not_to be_truthy
+      expect(json).to be_key(:filter)
+      expect(json).to be_key(:id)
+      expect(json).not_to be_key(:artist_id)
     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
+      expect(json).to be_key(:compositor_id)
+      expect(json).not_to be_key(:id)
+      expect(json).not_to be_key(:artist_id)
+    end
+  end
+
+  describe 'parameter renaming' do
+    context 'with a deeply nested parameter structure' do
+      let(:params) do
+        {
+          i_a: 'a',
+          i_b: {
+            i_c: 'c',
+            i_d: {
+              i_e: {
+                i_f: 'f',
+                i_g: 'g',
+                i_h: [
+                  {
+                    i_ha: 'ha1',
+                    i_hb: {
+                      i_hc: 'c'
+                    }
+                  },
+                  {
+                    i_ha: 'ha2',
+                    i_hb: {
+                      i_hc: 'c'
+                    }
+                  }
+                ]
+              }
+            }
+          }
+        }
+      end
+      let(:declared) do
+        {
+          o_a: 'a',
+          o_b: {
+            o_c: 'c',
+            o_d: {
+              o_e: {
+                o_f: 'f',
+                o_g: 'g',
+                o_h: [
+                  {
+                    o_ha: 'ha1',
+                    o_hb: {
+                      o_hc: 'c'
+                    }
+                  },
+                  {
+                    o_ha: 'ha2',
+                    o_hb: {
+                      o_hc: 'c'
+                    }
+                  }
+                ]
+              }
+            }
+          }
+        }
+      end
+      let(:params_keys) do
+        [
+          'i_a',
+          'i_b',
+          'i_b[i_c]',
+          'i_b[i_d]',
+          'i_b[i_d][i_e]',
+          'i_b[i_d][i_e][i_f]',
+          'i_b[i_d][i_e][i_g]',
+          'i_b[i_d][i_e][i_h]',
+          'i_b[i_d][i_e][i_h][i_ha]',
+          'i_b[i_d][i_e][i_h][i_hb]',
+          'i_b[i_d][i_e][i_h][i_hb][i_hc]'
+        ]
+      end
+
+      before do
+        subject.format :json
+        subject.params do
+          optional :i_a, type: String, as: :o_a
+          optional :i_b, type: Hash, as: :o_b do
+            optional :i_c, type: String, as: :o_c
+            optional :i_d, type: Hash, as: :o_d do
+              optional :i_e, type: Hash, as: :o_e do
+                optional :i_f, type: String, as: :o_f
+                optional :i_g, type: String, as: :o_g
+                optional :i_h, type: Array, as: :o_h do
+                  optional :i_ha, type: String, as: :o_ha
+                  optional :i_hb, type: Hash, as: :o_hb do
+                    optional :i_hc, type: String, as: :o_hc
+                  end
+                end
+              end
+            end
+          end
+        end
+        subject.post '/test' do
+          declared(params, include_missing: false)
+        end
+        subject.post '/test/no-mod' do
+          before = params.to_h
+          declared(params, include_missing: false)
+          after = params.to_h
+          { before: before, after: after }
+        end
+      end
+
+      it 'generates the correct parameter names for documentation' do
+        expect(subject.routes.first.params.keys).to match(params_keys)
+      end
+
+      it 'maps the renamed parameter correctly' do
+        post '/test', **params
+        expect(JSON.parse(last_response.body, symbolize_names: true)).to \
+          match(declared)
+      end
+
+      it 'maps no parameters when none are given' do
+        post '/test'
+        expect(JSON.parse(last_response.body)).to match({})
+      end
+
+      it 'does not modify the request params' do
+        post '/test/no-mod', **params
+        result = JSON.parse(last_response.body, symbolize_names: true)
+        expect(result[:before]).to match(result[:after])
+      end
+    end
+
+    context 'with a renamed root parameter' do
+      before do
+        subject.format :json
+        subject.params do
+          optional :email_address, type: String, regexp: /.+@.+/, as: :email
+        end
+        subject.post '/test' do
+          declared(params, include_missing: false)
+        end
+      end
+
+      it 'generates the correct parameter names for documentation' do
+        expect(subject.routes.first.params.keys).to match(%w[email_address])
+      end
+
+      it 'maps the renamed parameter correctly (original name)' do
+        post '/test', email_address: 'test@example.com'
+        expect(JSON.parse(last_response.body)).to \
+          match('email' => 'test@example.com')
+      end
+
+      it 'validates the renamed parameter correctly (original name)' do
+        post '/test', email_address: 'bad[at]example.com'
+        expect(JSON.parse(last_response.body)).to \
+          match('error' => 'email_address is invalid')
+      end
+
+      it 'ignores the renamed parameter (as name)' do
+        post '/test', email: 'test@example.com'
+        expect(JSON.parse(last_response.body)).to match({})
+      end
+    end
+
+    context 'with a renamed hash with nested parameters' do
+      before do
+        subject.format :json
+        subject.params do
+          optional :address, type: Hash, as: :address_attributes do
+            optional :street, type: String, values: ['Street 1', 'Street 2'],
+                              default: 'Street 1'
+            optional :city, type: String
+          end
+        end
+        subject.post '/test' do
+          declared(params, include_missing: false)
+        end
+      end
+
+      it 'generates the correct parameter names for documentation' do
+        expect(subject.routes.first.params.keys).to \
+          match(%w[address address[street] address[city]])
+      end
+
+      it 'maps the renamed parameter correctly (original name)' do
+        post '/test', address: { city: 'Berlin', street: 'Street 2', t: 't' }
+        expect(JSON.parse(last_response.body)).to \
+          match('address_attributes' => { 'city' => 'Berlin',
+                                          'street' => 'Street 2' })
+      end
+
+      it 'validates the renamed parameter correctly (original name)' do
+        post '/test', address: { street: 'unknown' }
+        expect(JSON.parse(last_response.body)).to \
+          match('error' => 'address[street] does not have a valid value')
+      end
+
+      it 'ignores the renamed parameter (as name)' do
+        post '/test', address_attributes: { city: 'Berlin', unknown: '1' }
+        expect(JSON.parse(last_response.body)).to match({})
+      end
+    end
+
+    context 'with a renamed hash with nested renamed parameter' do
+      before do
+        subject.format :json
+        subject.params do
+          optional :user, type: Hash, as: :user_attributes do
+            optional :email_address, type: String, regexp: /.+@.+/, as: :email
+          end
+        end
+        subject.post '/test' do
+          declared(params, include_missing: false)
+        end
+      end
+
+      it 'generates the correct parameter names for documentation' do
+        expect(subject.routes.first.params.keys).to \
+          match(%w[user user[email_address]])
+      end
+
+      it 'maps the renamed parameter correctly (original name)' do
+        post '/test', user: { email_address: 'test@example.com' }
+        expect(JSON.parse(last_response.body)).to \
+          match('user_attributes' => { 'email' => 'test@example.com' })
+      end
+
+      it 'validates the renamed parameter correctly (original name)' do
+        post '/test', user: { email_address: 'bad[at]example.com' }
+        expect(JSON.parse(last_response.body)).to \
+          match('error' => 'user[email_address] is invalid')
+      end
+
+      it 'ignores the renamed parameter (as name, 1)' do
+        post '/test', user: { email: 'test@example.com' }
+        expect(JSON.parse(last_response.body)).to \
+          match({ 'user_attributes' => {} })
+      end
+
+      it 'ignores the renamed parameter (as name, 2)' do
+        post '/test', user_attributes: { email_address: 'test@example.com' }
+        expect(JSON.parse(last_response.body)).to match({})
+      end
+
+      it 'ignores the renamed parameter (as name, 3)' do
+        post '/test', user_attributes: { email: 'test@example.com' }
+        expect(JSON.parse(last_response.body)).to match({})
+      end
     end
   end
 end