grape 1.3.2 → 1.5.2

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 = []
 
@@ -181,6 +181,7 @@ describe Grape::Entity do
         subject.get '/example' do
           c = Class.new do
             attr_reader :id
+
             def initialize(id)
               @id = id
             end
@@ -202,6 +203,7 @@ describe Grape::Entity do
         subject.get '/examples' do
           c = Class.new do
             attr_reader :id
+
             def initialize(id)
               @id = id
             end
@@ -226,6 +228,7 @@ describe Grape::Entity do
       subject.get '/example' do
         c = Class.new do
           attr_reader :name
+
           def initialize(args)
             @name = args[:name] || 'no name set'
           end
@@ -255,6 +258,7 @@ XML
       subject.get '/example' do
         c = Class.new do
           attr_reader :name
+
           def initialize(args)
             @name = args[:name] || 'no name set'
           end
@@ -284,6 +288,7 @@ XML
       subject.get '/example' do
         c = Class.new do
           attr_reader :name
+
           def initialize(args)
             @name = args[:name] || 'no name set'
           end
@@ -302,6 +307,7 @@ XML
       it 'present with multiple entities using optional symbol' do
         user = Class.new do
           attr_reader :name
+
           def initialize(args)
             @name = args[:name] || 'no name set'
           end

data/spec/grape/integration/rack_sendfile_spec.rb

@@ -4,12 +4,16 @@ require 'spec_helper'
 
 describe Rack::Sendfile do
   subject do
-    send_file = file_streamer
+    content_object = file_object
     app = Class.new(Grape::API) do
       use Rack::Sendfile
       format :json
       get do
-        file send_file
+        if content_object.is_a?(String)
+          sendfile content_object
+        else
+          stream content_object
+        end
       end
     end
 
@@ -22,9 +26,9 @@ describe Rack::Sendfile do
     app.call(env)
   end
 
-  context do
-    let(:file_streamer) do
-      double(:file_streamer, to_path: '/accel/mapping/some/path')
+  context 'when calling sendfile' do
+    let(:file_object) do
+      '/accel/mapping/some/path'
     end
 
     it 'contains Sendfile headers' do
@@ -33,9 +37,9 @@ describe Rack::Sendfile do
     end
   end
 
-  context do
-    let(:file_streamer) do
-      double(:file_streamer)
+  context 'when streaming non file content' do
+    let(:file_object) do
+      double(:file_object, each: nil)
     end
 
     it 'not contains Sendfile headers' do

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

@@ -36,7 +36,7 @@ describe Grape::Middleware::Auth::Strategies do
     RSpec::Matchers.define :be_challenge do
       match do |actual_response|
         actual_response.status == 401 &&
-          actual_response['WWW-Authenticate'] =~ /^Digest / &&
+          actual_response['WWW-Authenticate'].start_with?('Digest ') &&
           actual_response.body.empty?
       end
     end

data/spec/grape/middleware/error_spec.rb

@@ -30,7 +30,7 @@ describe Grape::Middleware::Error do
     opts = options
     Rack::Builder.app do
       use Spec::Support::EndpointFaker
-      use Grape::Middleware::Error, opts
+      use Grape::Middleware::Error, **opts
       run ErrorSpec::ErrApp
     end
   end

data/spec/grape/middleware/formatter_spec.rb

@@ -380,7 +380,7 @@ describe Grape::Middleware::Formatter do
 
   context 'send file' do
     let(:file) { double(File) }
-    let(:file_body) { Grape::ServeFile::FileResponse.new(file) }
+    let(:file_body) { Grape::ServeStream::StreamResponse.new(file) }
     let(:app) { ->(_env) { [200, {}, file_body] } }
 
     it 'returns a file response' do

data/spec/grape/middleware/stack_spec.rb

@@ -8,6 +8,7 @@ describe Grape::Middleware::Stack do
     class BarMiddleware; end
     class BlockMiddleware
       attr_reader :block
+
       def initialize(&block)
         @block = block
       end

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

@@ -633,6 +633,32 @@ describe Grape::Validations::ParamsScope do
       expect(last_response.status).to eq(200)
     end
 
+    it 'detect unmet nested dependency' do
+      subject.params do
+        requires :a, type: String, allow_blank: false, values: %w[x y z]
+        given a: ->(val) { val == 'z' } do
+          requires :inner3, type: Array, allow_blank: false do
+            requires :bar, type: String, allow_blank: false
+            given bar: ->(val) { val == 'b' } do
+              requires :baz, type: Array do
+                optional :baz_category, type: String
+              end
+            end
+            given bar: ->(val) { val == 'c' } do
+              requires :baz, type: Array do
+                requires :baz_category, type: String
+              end
+            end
+          end
+        end
+      end
+      subject.get('/nested-dependency') { declared(params).to_json }
+
+      get '/nested-dependency', a: 'z', inner3: [{ bar: 'c', baz: [{ unrelated: 'nope' }] }]
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq 'inner3[0][baz][0][baz_category] is missing'
+    end
+
     it 'includes the parameter within #declared(params)' do
       get '/test', a: true, b: true
 

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/array_coercer_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Grape::Validations::Types::ArrayCoercer do
+  subject { described_class.new(type) }
+
+  describe '#call' do
+    context 'an array of primitives' do
+      let(:type) { Array[String] }
+
+      it 'coerces elements in the array' do
+        expect(subject.call([10, 20])).to eq(%w[10 20])
+      end
+    end
+
+    context 'an array of arrays' do
+      let(:type) { Array[Array[Integer]] }
+
+      it 'coerces elements in the nested array' do
+        expect(subject.call([%w[10 20]])).to eq([[10, 20]])
+        expect(subject.call([['10'], ['20']])).to eq([[10], [20]])
+      end
+    end
+
+    context 'an array of sets' do
+      let(:type) { Array[Set[Integer]] }
+
+      it 'coerces elements in the nested set' do
+        expect(subject.call([%w[10 20]])).to eq([Set[10, 20]])
+        expect(subject.call([['10'], ['20']])).to eq([Set[10], Set[20]])
+      end
+    end
+  end
+end

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

@@ -7,7 +7,19 @@ describe Grape::Validations::Types::PrimitiveCoercer do
 
   subject { described_class.new(type, strict) }
 
-  describe '.call' do
+  describe '#call' do
+    context 'BigDecimal' do
+      let(:type) { BigDecimal }
+
+      it 'coerces to BigDecimal' do
+        expect(subject.call(5)).to eq(BigDecimal(5))
+      end
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
     context 'Boolean' do
       let(:type) { Grape::API::Boolean }
 
@@ -26,6 +38,50 @@ describe Grape::Validations::Types::PrimitiveCoercer do
       it 'returns an error when the given value cannot be coerced' do
         expect(subject.call(123)).to be_instance_of(Grape::Validations::Types::InvalidValue)
       end
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'DateTime' do
+      let(:type) { DateTime }
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'Float' do
+      let(:type) { Float }
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'Integer' do
+      let(:type) { Integer }
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'Numeric' do
+      let(:type) { Numeric }
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
+    end
+
+    context 'Time' do
+      let(:type) { Time }
+
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
+      end
     end
 
     context 'String' do
@@ -34,13 +90,17 @@ describe Grape::Validations::Types::PrimitiveCoercer do
       it 'coerces to String' do
         expect(subject.call(10)).to eq('10')
       end
+
+      it 'does not coerce an empty string to nil' do
+        expect(subject.call('')).to eq('')
+      end
     end
 
-    context 'BigDecimal' do
-      let(:type) { BigDecimal }
+    context 'Symbol' do
+      let(:type) { Symbol }
 
-      it 'coerces to BigDecimal' do
-        expect(subject.call(5)).to eq(BigDecimal(5))
+      it 'coerces an empty string to nil' do
+        expect(subject.call('')).to be_nil
       end
     end
 

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Grape::Validations::Types::SetCoercer do
+  subject { described_class.new(type) }
+
+  describe '#call' do
+    context 'a set of primitives' do
+      let(:type) { Set[String] }
+
+      it 'coerces elements to the set' do
+        expect(subject.call([10, 20])).to eq(Set['10', '20'])
+      end
+    end
+
+    context 'a set of sets' do
+      let(:type) { Set[Set[Integer]] }
+
+      it 'coerces elements in the nested set' do
+        expect(subject.call([%w[10 20]])).to eq(Set[Set[10, 20]])
+        expect(subject.call([['10'], ['20']])).to eq(Set[Set[10], Set[20]])
+      end
+    end
+
+    context 'a set of sets of arrays' do
+      let(:type) { Set[Set[Array[Integer]]] }
+
+      it 'coerces elements in the nested set' do
+        expect(subject.call([[['10'], ['20']]])).to eq(Set[Set[Array[10], Array[20]]])
+      end
+    end
+  end
+end

data/spec/grape/validations/validators/coerce_spec.rb

@@ -227,23 +227,51 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.body).to eq('NilClass')
       end
 
-      it 'is a custom type' do
-        subject.params do
-          requires :uri, coerce: SecureURIOnly
-        end
-        subject.get '/secure_uri' do
-          params[:uri].class
+      context 'a custom type' do
+        it 'coerces the given value' do
+          subject.params do
+            requires :uri, coerce: SecureURIOnly
+          end
+          subject.get '/secure_uri' do
+            params[:uri].class
+          end
+
+          get 'secure_uri', uri: 'https://www.example.com'
+
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('URI::HTTPS')
+
+          get 'secure_uri', uri: 'http://www.example.com'
+
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('uri is invalid')
         end
 
-        get 'secure_uri', uri: 'https://www.example.com'
+        context 'returning the InvalidValue instance when invalid' do
+          let(:custom_type) do
+            Class.new do
+              def self.parse(_val)
+                Grape::Types::InvalidValue.new('must be unique')
+              end
+            end
+          end
 
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('URI::HTTPS')
+          it 'uses a custom message added to the invalid value' do
+            type = custom_type
 
-        get 'secure_uri', uri: 'http://www.example.com'
+            subject.params do
+              requires :name, type: type
+            end
+            subject.get '/whatever' do
+              params[:name].class
+            end
 
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('uri is invalid')
+            get 'whatever', name: 'Bob'
+
+            expect(last_response.status).to eq(400)
+            expect(last_response.body).to eq('name must be unique')
+          end
+        end
       end
 
       context 'Array' do
@@ -424,6 +452,165 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.status).to eq(200)
         expect(last_response.body).to eq(integer_class_name)
       end
+
+      context 'nil values' do
+        context 'primitive types' do
+          Grape::Validations::Types::PRIMITIVES.each do |type|
+            it 'respects the nil value' do
+              subject.params do
+                requires :param, type: type
+              end
+              subject.get '/nil_value' do
+                params[:param].class
+              end
+
+              get '/nil_value', param: nil
+              expect(last_response.status).to eq(200)
+              expect(last_response.body).to eq('NilClass')
+            end
+          end
+        end
+
+        context 'structures types' do
+          Grape::Validations::Types::STRUCTURES.each do |type|
+            it 'respects the nil value' do
+              subject.params do
+                requires :param, type: type
+              end
+              subject.get '/nil_value' do
+                params[:param].class
+              end
+
+              get '/nil_value', param: nil
+              expect(last_response.status).to eq(200)
+              expect(last_response.body).to eq('NilClass')
+            end
+          end
+        end
+
+        context 'special types' do
+          Grape::Validations::Types::SPECIAL.each_key do |type|
+            it 'respects the nil value' do
+              subject.params do
+                requires :param, type: type
+              end
+              subject.get '/nil_value' do
+                params[:param].class
+              end
+
+              get '/nil_value', param: nil
+              expect(last_response.status).to eq(200)
+              expect(last_response.body).to eq('NilClass')
+            end
+          end
+
+          context 'variant-member-type collections' do
+            [
+              Array[Integer, String],
+              [Integer, String, Array[Integer, String]]
+            ].each do |type|
+              it 'respects the nil value' do
+                subject.params do
+                  requires :param, type: type
+                end
+                subject.get '/nil_value' do
+                  params[:param].class
+                end
+
+                get '/nil_value', param: nil
+                expect(last_response.status).to eq(200)
+                expect(last_response.body).to eq('NilClass')
+              end
+            end
+          end
+        end
+      end
+
+      context 'empty string' do
+        context 'primitive types' do
+          (Grape::Validations::Types::PRIMITIVES - [String]).each do |type|
+            it "is coerced to nil for type #{type}" do
+              subject.params do
+                requires :param, type: type
+              end
+              subject.get '/empty_string' do
+                params[:param].class
+              end
+
+              get '/empty_string', param: ''
+              expect(last_response.status).to eq(200)
+              expect(last_response.body).to eq('NilClass')
+            end
+          end
+
+          it 'is not coerced to nil for type String' do
+            subject.params do
+              requires :param, type: String
+            end
+            subject.get '/empty_string' do
+              params[:param].class
+            end
+
+            get '/empty_string', param: ''
+            expect(last_response.status).to eq(200)
+            expect(last_response.body).to eq('String')
+          end
+        end
+
+        context 'structures types' do
+          (Grape::Validations::Types::STRUCTURES - [Hash]).each do |type|
+            it "is coerced to nil for type #{type}" do
+              subject.params do
+                requires :param, type: type
+              end
+              subject.get '/empty_string' do
+                params[:param].class
+              end
+
+              get '/empty_string', param: ''
+              expect(last_response.status).to eq(200)
+              expect(last_response.body).to eq('NilClass')
+            end
+          end
+        end
+
+        context 'special types' do
+          (Grape::Validations::Types::SPECIAL.keys - [File, Rack::Multipart::UploadedFile]).each do |type|
+            it "is coerced to nil for type #{type}" do
+              subject.params do
+                requires :param, type: type
+              end
+              subject.get '/empty_string' do
+                params[:param].class
+              end
+
+              get '/empty_string', param: ''
+              expect(last_response.status).to eq(200)
+              expect(last_response.body).to eq('NilClass')
+            end
+          end
+
+          context 'variant-member-type collections' do
+            [
+              Array[Integer, String],
+              [Integer, String, Array[Integer, String]]
+            ].each do |type|
+              it "is coerced to nil for type #{type}" do
+                subject.params do
+                  requires :param, type: type
+                end
+                subject.get '/empty_string' do
+                  params[:param].class
+                end
+
+                get '/empty_string', param: ''
+                expect(last_response.status).to eq(200)
+                expect(last_response.body).to eq('NilClass')
+              end
+            end
+          end
+        end
+      end
     end
 
     context 'using coerce_with' do
@@ -461,6 +648,30 @@ describe Grape::Validations::CoerceValidator do
         expect(JSON.parse(last_response.body)).to eq(%w[a b c d])
       end
 
+      it 'parses parameters with Array[Array[String]] type and coerce_with' do
+        subject.params do
+          requires :values, type: Array[Array[String]], coerce_with: ->(val) { val.is_a?(String) ? [val.split(/,/).map(&:strip)] : val }
+        end
+        subject.post '/coerce_nested_strings' do
+          params[:values]
+        end
+
+        post '/coerce_nested_strings', ::Grape::Json.dump(values: 'a,b,c,d'), 'CONTENT_TYPE' => 'application/json'
+        expect(last_response.status).to eq(201)
+        expect(JSON.parse(last_response.body)).to eq([%w[a b c d]])
+
+        post '/coerce_nested_strings', ::Grape::Json.dump(values: [%w[a c], %w[b]]), 'CONTENT_TYPE' => 'application/json'
+        expect(last_response.status).to eq(201)
+        expect(JSON.parse(last_response.body)).to eq([%w[a c], %w[b]])
+
+        post '/coerce_nested_strings', ::Grape::Json.dump(values: [[]]), 'CONTENT_TYPE' => 'application/json'
+        expect(last_response.status).to eq(201)
+        expect(JSON.parse(last_response.body)).to eq([[]])
+
+        post '/coerce_nested_strings', ::Grape::Json.dump(values: [['a', { bar: 0 }], ['b']]), 'CONTENT_TYPE' => 'application/json'
+        expect(last_response.status).to eq(400)
+      end
+
       it 'parses parameters with Array[Integer] type' do
         subject.params do
           requires :values, type: Array[Integer], coerce_with: ->(val) { val.split(/\s+/).map(&:to_i) }
@@ -752,19 +963,6 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.body).to eq('String')
       end
 
-      it 'respects nil values' do
-        subject.params do
-          optional :a, types: [File, String]
-        end
-        subject.get '/' do
-          params[:a].class.to_s
-        end
-
-        get '/', a: nil
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('NilClass')
-      end
-
       it 'fails when no coercion is possible' do
         subject.params do
           requires :a, types: [Boolean, Integer]