grape 1.3.0 → 1.5.2

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

@@ -154,6 +154,49 @@ describe Grape::Validations::CoerceValidator do
     end
 
     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
+
+        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
+
+      it 'BigDecimal' do
+        subject.params do
+          requires :bigdecimal, coerce: BigDecimal
+        end
+        subject.get '/bigdecimal' do
+          params[:bigdecimal].class
+        end
+
+        get '/bigdecimal', bigdecimal: '45'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('BigDecimal')
+      end
+
       it 'Integer' do
         subject.params do
           requires :int, coerce: Integer
@@ -167,23 +210,68 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.body).to eq(integer_class_name)
       end
 
-      it 'is a custom type' do
+      it 'String' do
         subject.params do
-          requires :uri, coerce: SecureURIOnly
+          requires :string, coerce: String
         end
-        subject.get '/secure_uri' do
-          params[:uri].class
+        subject.get '/string' do
+          params[:string].class
         end
 
-        get 'secure_uri', uri: 'https://www.example.com'
+        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('URI::HTTPS')
+        expect(last_response.body).to eq('NilClass')
+      end
+
+      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: 'http://www.example.com'
+          get 'secure_uri', uri: 'https://www.example.com'
 
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('uri is invalid')
+          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 '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
+
+          it 'uses a custom message added to the invalid value' do
+            type = custom_type
+
+            subject.params do
+              requires :name, type: type
+            end
+            subject.get '/whatever' do
+              params[:name].class
+            end
+
+            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
@@ -281,119 +369,247 @@ describe Grape::Validations::CoerceValidator do
         end
       end
 
-      it 'Bool' do
+      it 'Boolean' do
         subject.params do
-          requires :bool, coerce: Grape::API::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
 
@@ -432,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) }
@@ -514,6 +754,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