grape 1.5.0 → 1.6.0

data/spec/grape/endpoint/declared_spec.rb

@@ -16,6 +16,7 @@ describe Grape::Endpoint do
         requires :first
         optional :second
         optional :third, default: 'third-default'
+        optional :multiple_types, types: [Integer, String]
         optional :nested, type: Hash do
           optional :fourth
           optional :fifth
@@ -96,6 +97,16 @@ 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
+      subject.get '/declared' do
+        declared(params, include_missing: true)
+      end
+
+      get '/declared?first=present'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body)['multiple_types']).to be_nil
+    end
+
     it 'does not work in a before filter' do
       subject.before do
         declared(params)
@@ -113,7 +124,7 @@ describe Grape::Endpoint do
       end
       get '/declared?first=present'
       expect(last_response.status).to eq(200)
-      expect(JSON.parse(last_response.body).keys.size).to eq(10)
+      expect(JSON.parse(last_response.body).keys.size).to eq(11)
     end
 
     it 'has a optional param with default value all the time' do
@@ -587,4 +598,251 @@ describe Grape::Endpoint do
       expect(json.key?(:artist_id)).not_to be_truthy
     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

data/spec/grape/endpoint_spec.rb

@@ -150,7 +150,7 @@ describe Grape::Endpoint do
     end
     it 'includes headers passed as symbols' do
       env = Rack::MockRequest.env_for('/headers')
-      env['HTTP_SYMBOL_HEADER'.to_sym] = 'Goliath passes symbols'
+      env[:HTTP_SYMBOL_HEADER] = 'Goliath passes symbols'
       body = read_chunks(subject.call(env)[2]).join
       expect(JSON.parse(body)['Symbol-Header']).to eq('Goliath passes symbols')
     end
@@ -212,10 +212,10 @@ describe Grape::Endpoint do
       end
       get '/test', {}, 'HTTP_COOKIE' => 'delete_this_cookie=1; and_this=2'
       expect(last_response.body).to eq('3')
-      cookies = Hash[last_response.headers['Set-Cookie'].split("\n").map do |set_cookie|
+      cookies = last_response.headers['Set-Cookie'].split("\n").map do |set_cookie|
         cookie = CookieJar::Cookie.from_set_cookie 'http://localhost/test', set_cookie
         [cookie.name, cookie]
-      end]
+      end.to_h
       expect(cookies.size).to eq(2)
       %w[and_this delete_this_cookie].each do |cookie_name|
         cookie = cookies[cookie_name]
@@ -236,10 +236,10 @@ describe Grape::Endpoint do
       end
       get('/test', {}, 'HTTP_COOKIE' => 'delete_this_cookie=1; and_this=2')
       expect(last_response.body).to eq('3')
-      cookies = Hash[last_response.headers['Set-Cookie'].split("\n").map do |set_cookie|
+      cookies = last_response.headers['Set-Cookie'].split("\n").map do |set_cookie|
         cookie = CookieJar::Cookie.from_set_cookie 'http://localhost/test', set_cookie
         [cookie.name, cookie]
-      end]
+      end.to_h
       expect(cookies.size).to eq(2)
       %w[and_this delete_this_cookie].each do |cookie_name|
         cookie = cookies[cookie_name]
@@ -420,6 +420,19 @@ describe Grape::Endpoint do
         expect(last_response.status).to eq(201)
         expect(last_response.body).to eq('Bob')
       end
+
+      # Rack swallowed this error until v2.2.0
+      it 'returns a 400 if given an invalid multipart body', if: Gem::Version.new(Rack.release) >= Gem::Version.new('2.2.0') do
+        subject.params do
+          requires :file, type: Rack::Multipart::UploadedFile
+        end
+        subject.post '/upload' do
+          params[:file][:filename]
+        end
+        post '/upload', { file: '' }, 'CONTENT_TYPE' => 'multipart/form-data; boundary=foobar'
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('Empty message body supplied with multipart/form-data; boundary=foobar content-type')
+      end
     end
 
     it 'responds with a 415 for an unsupported content-type' do

data/spec/grape/entity_spec.rb

@@ -116,7 +116,7 @@ describe Grape::Entity do
       expect(last_response.body).to eq('Auto-detect!')
     end
 
-    it 'does not run autodetection for Entity when explicitely provided' do
+    it 'does not run autodetection for Entity when explicitly provided' do
       entity = Class.new(Grape::Entity)
       some_array = []
 
@@ -238,14 +238,14 @@ describe Grape::Entity do
       get '/example'
       expect(last_response.status).to eq(200)
       expect(last_response.headers['Content-type']).to eq('application/xml')
-      expect(last_response.body).to eq <<-XML
-<?xml version="1.0" encoding="UTF-8"?>
-<hash>
-  <example>
-    <name>johnnyiller</name>
-  </example>
-</hash>
-XML
+      expect(last_response.body).to eq <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <hash>
+          <example>
+            <name>johnnyiller</name>
+          </example>
+        </hash>
+      XML
     end
 
     it 'presents with json' do
@@ -326,7 +326,7 @@ XML
         end
         get '/example'
         expect_response_json = {
-          'page'  => 1,
+          'page' => 1,
           'user1' => { 'name' => 'user1' },
           'user2' => { 'name' => 'user2' }
         }

data/spec/grape/middleware/auth/dsl_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Grape::Middleware::Auth::DSL do
   subject { Class.new(Grape::API) }
 
-  let(:block) { ->() {} }
+  let(:block) { -> {} }
   let(:settings) do
     {
       opaque: 'secret',

data/spec/grape/middleware/error_spec.rb

@@ -16,8 +16,7 @@ describe Grape::Middleware::Error do
 
     class ErrApp
       class << self
-        attr_accessor :error
-        attr_accessor :format
+        attr_accessor :error, :format
 
         def call(_env)
           throw :error, error

data/spec/grape/middleware/formatter_spec.rb

@@ -20,7 +20,7 @@ describe Grape::Middleware::Formatter do
       let(:body) { ['foo'] }
       it 'calls #to_json since default format is json' do
         body.instance_eval do
-          def to_json
+          def to_json(*_args)
             '"bar"'
           end
         end
@@ -33,7 +33,7 @@ describe Grape::Middleware::Formatter do
       let(:body) { { 'foos' => [{ 'bar' => 'baz' }] } }
       it 'calls #to_json if the content type is jsonapi' do
         body.instance_eval do
-          def to_json
+          def to_json(*_args)
             '{"foos":[{"bar":"baz"}] }'
           end
         end

data/spec/grape/middleware/stack_spec.rb

@@ -5,7 +5,9 @@ require 'spec_helper'
 describe Grape::Middleware::Stack do
   module StackSpec
     class FooMiddleware; end
+
     class BarMiddleware; end
+
     class BlockMiddleware
       attr_reader :block
 
@@ -15,7 +17,7 @@ describe Grape::Middleware::Stack do
     end
   end
 
-  let(:proc) { ->() {} }
+  let(:proc) { -> {} }
   let(:others) { [[:use, StackSpec::BarMiddleware], [:insert_before, StackSpec::BarMiddleware, StackSpec::BlockMiddleware, proc]] }
 
   subject { Grape::Middleware::Stack.new }
@@ -35,8 +37,7 @@ describe Grape::Middleware::Stack do
       expect { subject.use StackSpec::BarMiddleware, false, my_arg: 42 }
         .to change { subject.size }.by(1)
       expect(subject.last).to eq(StackSpec::BarMiddleware)
-      expect(subject.last.args).to eq([false])
-      expect(subject.last.opts).to eq(my_arg: 42)
+      expect(subject.last.args).to eq([false, { my_arg: 42 }])
     end
 
     it 'pushes a middleware class with block arguments onto the stack' do

data/spec/grape/request_spec.rb

@@ -75,7 +75,7 @@ module Grape
         Grape.config.reset
       end
 
-      subject(:request_params) { Grape::Request.new(env, opts).params }
+      subject(:request_params) { Grape::Request.new(env, **opts).params }
 
       context 'when the API does not include a specific param builder' do
         let(:opts) { {} }

data/spec/grape/validations/multiple_attributes_iterator_spec.rb

@@ -13,8 +13,8 @@ describe Grape::Validations::MultipleAttributesIterator do
         { first: 'string', second: 'string' }
       end
 
-      it 'yields the whole params hash without the list of attrs' do
-        expect { |b| iterator.each(&b) }.to yield_with_args(params)
+      it 'yields the whole params hash and the skipped flag without the list of attrs' do
+        expect { |b| iterator.each(&b) }.to yield_with_args(params, false)
       end
     end
 
@@ -24,7 +24,17 @@ describe Grape::Validations::MultipleAttributesIterator do
       end
 
       it 'yields each element of the array without the list of attrs' do
-        expect { |b| iterator.each(&b) }.to yield_successive_args(params[0], params[1])
+        expect { |b| iterator.each(&b) }.to yield_successive_args([params[0], false], [params[1], false])
+      end
+    end
+
+    context 'when params is empty optional placeholder' do
+      let(:params) do
+        [Grape::DSL::Parameters::EmptyOptionalValue, { first: 'string2', second: 'string2' }]
+      end
+
+      it 'yields each element of the array without the list of attrs' do
+        expect { |b| iterator.each(&b) }.to yield_successive_args([Grape::DSL::Parameters::EmptyOptionalValue, true], [params[1], false])
       end
     end
   end

data/spec/grape/validations/params_scope_spec.rb

@@ -98,6 +98,7 @@ describe Grape::Validations::ParamsScope do
 
         def self.parse(value)
           raise if value == 'invalid'
+
           new(value)
         end
 
@@ -144,7 +145,7 @@ describe Grape::Validations::ParamsScope do
       get '/renaming-coerced', foo: ' there we go '
 
       expect(last_response.status).to eq(200)
-      expect(last_response.body).to eq('there we go-')
+      expect(last_response.body).to eq('-there we go')
     end
 
     it do
@@ -180,6 +181,28 @@ describe Grape::Validations::ParamsScope do
       expect(last_response.status).to eq(200)
       expect(last_response.body).to eq('{"baz":{"qux":"any"}}')
     end
+
+    it 'renaming can be defined before default' do
+      subject.params do
+        optional :foo, as: :bar, default: 'before'
+      end
+      subject.get('/rename-before-default') { declared(params)[:bar] }
+      get '/rename-before-default'
+
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('before')
+    end
+
+    it 'renaming can be defined after default' do
+      subject.params do
+        optional :foo, default: 'after', as: :bar
+      end
+      subject.get('/rename-after-default') { declared(params)[:bar] }
+      get '/rename-after-default'
+
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('after')
+    end
   end
 
   context 'array without coerce type explicitly given' do
@@ -568,7 +591,7 @@ describe Grape::Validations::ParamsScope do
     it 'allows renaming of dependent on parameter' do
       subject.params do
         optional :a, as: :b
-        given b: ->(val) { val == 'x' } do
+        given a: ->(val) { val == 'x' } do
           requires :c
         end
       end
@@ -582,7 +605,7 @@ describe Grape::Validations::ParamsScope do
       expect(last_response.status).to eq 200
     end
 
-    it 'raises an error if the dependent parameter is not the renamed one' do
+    it 'does not raise if the dependent parameter is not the renamed one' do
       expect do
         subject.params do
           optional :a, as: :b
@@ -590,6 +613,17 @@ describe Grape::Validations::ParamsScope do
             requires :c
           end
         end
+      end.not_to raise_error
+    end
+
+    it 'raises an error if the dependent parameter is the renamed one' do
+      expect do
+        subject.params do
+          optional :a, as: :b
+          given :b do
+            requires :c
+          end
+        end
       end.to raise_error(Grape::Exceptions::UnknownParameter)
     end
 

data/spec/grape/validations/single_attribute_iterator_spec.rb

@@ -15,7 +15,7 @@ describe Grape::Validations::SingleAttributeIterator do
 
       it 'yields params and every single attribute from the list' do
         expect { |b| iterator.each(&b) }
-          .to yield_successive_args([params, :first, false], [params, :second, false])
+          .to yield_successive_args([params, :first, false, false], [params, :second, false, false])
       end
     end
 
@@ -26,8 +26,8 @@ describe Grape::Validations::SingleAttributeIterator do
 
       it 'yields every single attribute from the list for each of the array elements' do
         expect { |b| iterator.each(&b) }.to yield_successive_args(
-          [params[0], :first, false], [params[0], :second, false],
-          [params[1], :first, false], [params[1], :second, false]
+          [params[0], :first, false, false], [params[0], :second, false, false],
+          [params[1], :first, false, false], [params[1], :second, false, false]
         )
       end
 
@@ -36,9 +36,20 @@ describe Grape::Validations::SingleAttributeIterator do
 
         it 'marks params with empty values' do
           expect { |b| iterator.each(&b) }.to yield_successive_args(
-            [params[0], :first, true], [params[0], :second, true],
-            [params[1], :first, true], [params[1], :second, true],
-            [params[2], :first, false], [params[2], :second, false]
+            [params[0], :first, true, false], [params[0], :second, true, false],
+            [params[1], :first, true, false], [params[1], :second, true, false],
+            [params[2], :first, false, false], [params[2], :second, false, false]
+          )
+        end
+      end
+
+      context 'when missing optional value' do
+        let(:params) { [Grape::DSL::Parameters::EmptyOptionalValue, 10] }
+
+        it 'marks params with skipped values' do
+          expect { |b| iterator.each(&b) }.to yield_successive_args(
+            [params[0], :first, false, true], [params[0], :second, false, true],
+            [params[1], :first, false, false], [params[1], :second, false, false]
           )
         end
       end

data/spec/grape/validations/types/primitive_coercer_spec.rb

@@ -12,7 +12,7 @@ describe Grape::Validations::Types::PrimitiveCoercer do
       let(:type) { BigDecimal }
 
       it 'coerces to BigDecimal' do
-        expect(subject.call(5)).to eq(BigDecimal(5))
+        expect(subject.call(5)).to eq(BigDecimal('5'))
       end
 
       it 'coerces an empty string to nil' do
@@ -127,7 +127,7 @@ describe Grape::Validations::Types::PrimitiveCoercer do
         end
 
         it 'returns a value as it is when the given value is BigDecimal' do
-          expect(subject.call(BigDecimal(0))).to eq(BigDecimal(0))
+          expect(subject.call(BigDecimal('0'))).to eq(BigDecimal('0'))
         end
       end
     end