grape 1.2.5 → 1.4.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::AllOrNoneOfValidator do

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::AllowBlankValidator do

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::AtLeastOneOfValidator do

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::CoerceValidator do
@@ -10,11 +12,13 @@ describe Grape::Validations::CoerceValidator do
   end
 
   describe 'coerce' do
-    module CoerceValidatorSpec
-      class User
-        include Virtus.model
-        attribute :id, Integer
-        attribute :name, String
+    class SecureURIOnly
+      def self.parse(value)
+        URI.parse(value)
+      end
+
+      def self.parsed?(value)
+        value.is_a? URI::HTTPS
       end
     end
 
@@ -96,6 +100,7 @@ describe Grape::Validations::CoerceValidator do
 
         it 'respects :coerce_with' do
           get '/', a: 'yup'
+
           expect(last_response.status).to eq(200)
           expect(last_response.body).to eq('TrueClass')
         end
@@ -148,26 +153,50 @@ describe Grape::Validations::CoerceValidator do
       expect(last_response.body).to eq('array int works')
     end
 
-    context 'complex objects' do
-      it 'error on malformed input for complex objects' do
-        subject.params do
-          requires :user, type: CoerceValidatorSpec::User
+    context 'coerces' do
+      context 'json' do
+        let(:headers) { { 'CONTENT_TYPE' => 'application/json', 'ACCEPT' => 'application/json' } }
+
+        it 'BigDecimal' do
+          subject.params do
+            requires :bigdecimal, type: BigDecimal
+          end
+          subject.post '/bigdecimal' do
+            "#{params[:bigdecimal].class} #{params[:bigdecimal].to_f}"
+          end
+
+          post '/bigdecimal', { bigdecimal: 45.1 }.to_json, headers
+          expect(last_response.status).to eq(201)
+          expect(last_response.body).to eq('BigDecimal 45.1')
         end
-        subject.get '/user' do
-          'complex works'
+
+        it 'Boolean' do
+          subject.params do
+            requires :boolean, type: Boolean
+          end
+          subject.post '/boolean' do
+            params[:boolean]
+          end
+
+          post '/boolean', { boolean: 'true' }.to_json, headers
+          expect(last_response.status).to eq(201)
+          expect(last_response.body).to eq('true')
         end
+      end
 
-        get '/user', user: '32'
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('user is invalid')
+      it 'BigDecimal' do
+        subject.params do
+          requires :bigdecimal, coerce: BigDecimal
+        end
+        subject.get '/bigdecimal' do
+          params[:bigdecimal].class
+        end
 
-        get '/user', user: { id: 32, name: 'Bob' }
+        get '/bigdecimal', bigdecimal: '45'
         expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('complex works')
+        expect(last_response.body).to eq('BigDecimal')
       end
-    end
 
-    context 'coerces' do
       it 'Integer' do
         subject.params do
           requires :int, coerce: Integer
@@ -181,6 +210,42 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.body).to eq(integer_class_name)
       end
 
+      it 'String' do
+        subject.params do
+          requires :string, coerce: String
+        end
+        subject.get '/string' do
+          params[:string].class
+        end
+
+        get '/string', string: 45
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('String')
+
+        get '/string', string: nil
+        expect(last_response.status).to eq(200)
+        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
+        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
+
       context 'Array' do
         it 'Array of Integers' do
           subject.params do
@@ -197,7 +262,7 @@ describe Grape::Validations::CoerceValidator do
 
         it 'Array of Bools' do
           subject.params do
-            requires :arry, coerce: Array[Virtus::Attribute::Boolean]
+            requires :arry, coerce: Array[Grape::API::Boolean]
           end
           subject.get '/array' do
             params[:arry][0].class
@@ -208,27 +273,6 @@ describe Grape::Validations::CoerceValidator do
           expect(last_response.body).to eq('TrueClass')
         end
 
-        it 'Array of Complex' do
-          subject.params do
-            requires :arry, coerce: Array[CoerceValidatorSpec::User]
-          end
-          subject.get '/array' do
-            params[:arry].size
-          end
-
-          get 'array', arry: [31]
-          expect(last_response.status).to eq(400)
-          expect(last_response.body).to eq('arry is invalid')
-
-          get 'array', arry: { id: 31, name: 'Alice' }
-          expect(last_response.status).to eq(400)
-          expect(last_response.body).to eq('arry is invalid')
-
-          get 'array', arry: [{ id: 31, name: 'Alice' }]
-          expect(last_response.status).to eq(200)
-          expect(last_response.body).to eq('1')
-        end
-
         it 'Array of type implementing parse' do
           subject.params do
             requires :uri, type: Array[URI]
@@ -253,17 +297,7 @@ describe Grape::Validations::CoerceValidator do
           expect(last_response.body).to eq('Set,URI::HTTP,1')
         end
 
-        it 'Array of class implementing parse and parsed?' do
-          class SecureURIOnly
-            def self.parse(value)
-              URI.parse(value)
-            end
-
-            def self.parsed?(value)
-              value.is_a? URI::HTTPS
-            end
-          end
-
+        it 'Array of a custom type' do
           subject.params do
             requires :uri, type: Array[SecureURIOnly]
           end
@@ -295,7 +329,7 @@ describe Grape::Validations::CoerceValidator do
 
         it 'Set of Bools' do
           subject.params do
-            requires :set, coerce: Set[Virtus::Attribute::Boolean]
+            requires :set, coerce: Set[Grape::API::Boolean]
           end
           subject.get '/set' do
             params[:set].first.class
@@ -307,119 +341,247 @@ describe Grape::Validations::CoerceValidator do
         end
       end
 
-      it 'Bool' do
+      it 'Boolean' do
         subject.params do
-          requires :bool, coerce: Virtus::Attribute::Boolean
+          requires :boolean, type: Boolean
         end
-        subject.get '/bool' do
-          params[:bool].class
+        subject.get '/boolean' do
+          params[:boolean].class
         end
 
-        get '/bool', bool: 1
+        get '/boolean', boolean: 1
         expect(last_response.status).to eq(200)
         expect(last_response.body).to eq('TrueClass')
+      end
 
-        get '/bool', bool: 0
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('FalseClass')
+      context 'File' do
+        let(:file) { Rack::Test::UploadedFile.new(__FILE__) }
+        let(:filename) { File.basename(__FILE__).to_s }
 
-        get '/bool', bool: 'false'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('FalseClass')
+        it 'Rack::Multipart::UploadedFile' do
+          subject.params do
+            requires :file, type: Rack::Multipart::UploadedFile
+          end
+          subject.post '/upload' do
+            params[:file][:filename]
+          end
 
-        get '/bool', bool: 'true'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('TrueClass')
-      end
+          post '/upload', file: file
+          expect(last_response.status).to eq(201)
+          expect(last_response.body).to eq(filename)
 
-      it 'Boolean' do
-        subject.params do
-          optional :boolean, type: Boolean, default: true
-        end
-        subject.get '/boolean' do
-          params[:boolean].class
+          post '/upload', file: 'not a file'
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('file is invalid')
         end
 
-        get '/boolean'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('TrueClass')
-
-        get '/boolean', boolean: true
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('TrueClass')
+        it 'File' do
+          subject.params do
+            requires :file, coerce: File
+          end
+          subject.post '/upload' do
+            params[:file][:filename]
+          end
 
-        get '/boolean', boolean: false
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('FalseClass')
+          post '/upload', file: file
+          expect(last_response.status).to eq(201)
+          expect(last_response.body).to eq(filename)
 
-        get '/boolean', boolean: 'true'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('TrueClass')
+          post '/upload', file: 'not a file'
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('file is invalid')
 
-        get '/boolean', boolean: 'false'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('FalseClass')
+          post '/upload', file: { filename: 'fake file', tempfile: '/etc/passwd' }
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('file is invalid')
+        end
 
-        get '/boolean', boolean: 123
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('boolean is invalid')
+        it 'collection' do
+          subject.params do
+            requires :files, type: Array[File]
+          end
+          subject.post '/upload' do
+            params[:files].first[:filename]
+          end
 
-        get '/boolean', boolean: '123'
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('boolean is invalid')
+          post '/upload', files: [file]
+          expect(last_response.status).to eq(201)
+          expect(last_response.body).to eq(filename)
+        end
       end
 
-      it 'Rack::Multipart::UploadedFile' do
+      it 'Nests integers' do
         subject.params do
-          requires :file, type: Rack::Multipart::UploadedFile
+          requires :integers, type: Hash do
+            requires :int, coerce: Integer
+          end
         end
-        subject.post '/upload' do
-          params[:file][:filename]
+        subject.get '/int' do
+          params[:integers][:int].class
         end
 
-        post '/upload', file: Rack::Test::UploadedFile.new(__FILE__)
-        expect(last_response.status).to eq(201)
-        expect(last_response.body).to eq(File.basename(__FILE__).to_s)
-
-        post '/upload', file: 'not a file'
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('file is invalid')
+        get '/int', integers: { int: '45' }
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq(integer_class_name)
       end
 
-      it 'File' do
-        subject.params do
-          requires :file, coerce: File
+      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
-        subject.post '/upload' do
-          params[:file][:filename]
+
+        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
 
-        post '/upload', file: Rack::Test::UploadedFile.new(__FILE__)
-        expect(last_response.status).to eq(201)
-        expect(last_response.body).to eq(File.basename(__FILE__).to_s)
+        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
 
-        post '/upload', file: 'not a file'
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('file is invalid')
+              get '/nil_value', param: nil
+              expect(last_response.status).to eq(200)
+              expect(last_response.body).to eq('NilClass')
+            end
+          end
 
-        post '/upload', file: { filename: 'fake file', tempfile: '/etc/passwd' }
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('file is invalid')
+          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
 
-      it 'Nests integers' do
-        subject.params do
-          requires :integers, type: Hash do
-            requires :int, coerce: Integer
+      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
-        subject.get '/int' do
-          params[:integers][:int].class
+
+        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
 
-        get '/int', integers: { int: '45' }
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq(integer_class_name)
+        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
 
@@ -443,19 +605,19 @@ describe Grape::Validations::CoerceValidator do
 
       it 'parses parameters with Array[String] type' do
         subject.params do
-          requires :values, type: Array[String], coerce_with: ->(val) { val.split(/\s+/).map(&:to_i) }
+          requires :values, type: Array[String], coerce_with: ->(val) { val.split(/\s+/) }
         end
-        subject.get '/ints' do
+        subject.get '/strings' do
           params[:values]
         end
 
-        get '/ints', values: '1 2 3 4'
+        get '/strings', values: '1 2 3 4'
         expect(last_response.status).to eq(200)
         expect(JSON.parse(last_response.body)).to eq(%w[1 2 3 4])
 
-        get '/ints', values: 'a b c d'
+        get '/strings', values: 'a b c d'
         expect(last_response.status).to eq(200)
-        expect(JSON.parse(last_response.body)).to eq(%w[0 0 0 0])
+        expect(JSON.parse(last_response.body)).to eq(%w[a b c d])
       end
 
       it 'parses parameters with Array[Integer] type' do
@@ -540,6 +702,46 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.body).to eq('3')
       end
 
+      context 'Integer type and coerce_with potentially returning nil' do
+        before do
+          subject.params do
+            requires :int, type: Integer, coerce_with: (lambda do |val|
+              if val == '0'
+                nil
+              elsif val.match?(/^-?\d+$/)
+                val.to_i
+              else
+                val
+              end
+            end)
+          end
+          subject.get '/' do
+            params[:int].class.to_s
+          end
+        end
+
+        it 'accepts value that coerces to nil' do
+          get '/', int: '0'
+
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('NilClass')
+        end
+
+        it 'coerces to Integer' do
+          get '/', int: '1'
+
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('Integer')
+        end
+
+        it 'returns invalid value if coercion returns a wrong type' do
+          get '/', int: 'lol'
+
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('int is invalid')
+        end
+      end
+
       it 'must be supplied with :type or :coerce' do
         expect do
           subject.params do
@@ -914,14 +1116,17 @@ describe Grape::Validations::CoerceValidator do
     end
 
     context 'converter' do
-      it 'does not build Virtus::Attribute multiple times' do
+      it 'does not build a coercer multiple times' do
         subject.params do
           requires :something, type: Array[String]
         end
         subject.get do
         end
 
-        expect(Virtus::Attribute).to receive(:build).at_most(2).times.and_call_original
+        expect(Grape::Validations::Types::ArrayCoercer).to(
+          receive(:new).at_most(:once).and_call_original
+        )
+
         10.times { get '/' }
       end
     end