grape 1.2.5 → 1.3.1

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,20 @@ 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
+    context 'coerces' do
+      it 'BigDecimal' do
         subject.params do
-          requires :user, type: CoerceValidatorSpec::User
+          requires :bigdecimal, coerce: BigDecimal
         end
-        subject.get '/user' do
-          'complex works'
+        subject.get '/bigdecimal' do
+          params[:bigdecimal].class
         end
 
-        get '/user', user: '32'
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('user is invalid')
-
-        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 +180,25 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.body).to eq(integer_class_name)
       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 +215,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 +226,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 +250,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 +282,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,66 +294,17 @@ describe Grape::Validations::CoerceValidator do
         end
       end
 
-      it 'Bool' do
-        subject.params do
-          requires :bool, coerce: Virtus::Attribute::Boolean
-        end
-        subject.get '/bool' do
-          params[:bool].class
-        end
-
-        get '/bool', bool: 1
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('TrueClass')
-
-        get '/bool', bool: 0
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('FalseClass')
-
-        get '/bool', bool: 'false'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('FalseClass')
-
-        get '/bool', bool: 'true'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('TrueClass')
-      end
-
       it 'Boolean' do
         subject.params do
-          optional :boolean, type: Boolean, default: true
+          requires :boolean, type: Boolean
         end
         subject.get '/boolean' do
           params[:boolean].class
         end
 
-        get '/boolean'
+        get '/boolean', boolean: 1
         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')
-
-        get '/boolean', boolean: false
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('FalseClass')
-
-        get '/boolean', boolean: 'true'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('TrueClass')
-
-        get '/boolean', boolean: 'false'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('FalseClass')
-
-        get '/boolean', boolean: 123
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('boolean is invalid')
-
-        get '/boolean', boolean: '123'
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('boolean is invalid')
       end
 
       it 'Rack::Multipart::UploadedFile' do
@@ -443,19 +381,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
@@ -914,14 +852,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

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

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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::ExactlyOneOfValidator do
@@ -98,7 +100,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
         validate
         expect(last_response.status).to eq 400
         expect(JSON.parse(last_response.body)).to eq(
-          'beer,wine,grapefruit' => ['are missing, exactly one parameter must be provided']
+          'beer,wine,grapefruit' => ['are mutually exclusive']
         )
       end
 
@@ -110,7 +112,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
           validate
           expect(last_response.status).to eq 400
           expect(JSON.parse(last_response.body)).to eq(
-            'beer,wine,grapefruit' => ['are missing, exactly one parameter must be provided']
+            'beer,wine,grapefruit' => ['are mutually exclusive']
           )
         end
       end
@@ -124,7 +126,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
         validate
         expect(last_response.status).to eq 400
         expect(JSON.parse(last_response.body)).to eq(
-          'beer,wine,grapefruit' => ['are missing, exactly one parameter must be provided']
+          'beer,grapefruit' => ['are mutually exclusive']
         )
       end
     end
@@ -137,7 +139,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
         validate
         expect(last_response.status).to eq 400
         expect(JSON.parse(last_response.body)).to eq(
-          'beer,wine,grapefruit' => ['you should choose one']
+          'beer,wine' => ['you should choose one']
         )
       end
     end
@@ -173,7 +175,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
         validate
         expect(last_response.status).to eq 400
         expect(JSON.parse(last_response.body)).to eq(
-          'item[beer],item[wine],item[grapefruit]' => ['are missing, exactly one parameter must be provided']
+          'item[beer],item[wine]' => ['are mutually exclusive']
         )
       end
     end
@@ -188,7 +190,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
           validate
           expect(last_response.status).to eq 400
           expect(JSON.parse(last_response.body)).to eq(
-            'item[beer],item[wine],item[grapefruit]' => ['are missing, exactly one parameter must be provided']
+            'item[beer],item[wine]' => ['are mutually exclusive']
           )
         end
       end
@@ -211,11 +213,11 @@ describe Grape::Validations::ExactlyOneOfValidator do
         validate
         expect(last_response.status).to eq 400
         expect(JSON.parse(last_response.body)).to eq(
-          'items[0][beer],items[0][wine],items[0][grapefruit]' => [
-            'are missing, exactly one parameter must be provided'
+          'items[0][beer],items[0][wine]' => [
+            'are mutually exclusive'
           ],
-          'items[1][beer],items[1][wine],items[1][grapefruit]' => [
-            'are missing, exactly one parameter must be provided'
+          'items[1][wine],items[1][grapefruit]' => [
+            'are mutually exclusive'
           ]
         )
       end
@@ -229,8 +231,8 @@ describe Grape::Validations::ExactlyOneOfValidator do
         validate
         expect(last_response.status).to eq 400
         expect(JSON.parse(last_response.body)).to eq(
-          'items[0][nested_items][0][beer],items[0][nested_items][0][wine],items[0][nested_items][0][grapefruit]' => [
-            'are missing, exactly one parameter must be provided'
+          'items[0][nested_items][0][beer],items[0][nested_items][0][wine]' => [
+            'are mutually exclusive'
           ]
         )
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::ExceptValuesValidator do
@@ -110,7 +112,7 @@ describe Grape::Validations::ExceptValuesValidator do
         optional: { type: Array[Integer], except_values: [10, 11], default: 12 },
         tests: [
           { value: 'invalid-type1', rc: 400, body: { error: 'type is invalid' }.to_json },
-          { value: 10, rc: 400, body: { error: 'type has a value not allowed' }.to_json },
+          { value: 10, rc: 400, body: { error: 'type is invalid' }.to_json },
           { value: [10], rc: 400, body: { error: 'type has a value not allowed' }.to_json },
           { value: ['3'], rc: 200, body: { type: [3] }.to_json },
           { value: [3], rc: 200, body: { type: [3] }.to_json },

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

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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::PresenceValidator do
@@ -269,4 +271,32 @@ describe Grape::Validations::PresenceValidator do
       expect(last_response.body).to eq('Hello optional'.to_json)
     end
   end
+
+  context 'with a custom type' do
+    it 'does not validate their type when it is missing' do
+      class CustomType
+        def self.parse(value)
+          return if value.blank?
+
+          new
+        end
+      end
+
+      subject.params do
+        requires :custom, type: CustomType
+      end
+      subject.get '/custom' do
+        'custom'
+      end
+
+      get 'custom'
+
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('{"error":"custom is missing"}')
+
+      get 'custom', custom: 'filled'
+
+      expect(last_response.status).to eq(200)
+    end
+  end
 end

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

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

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

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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::ValuesValidator do
@@ -222,6 +224,11 @@ describe Grape::Validations::ValuesValidator do
           requires :type, values: { proc: ->(v) { ValuesModel.values.include? v }, message: 'failed check' }
         end
         get '/proc/message'
+
+        params do
+          optional :name, type: String, values: %w[a b], allow_blank: true
+        end
+        get '/allow_blank'
       end
     end
   end
@@ -431,11 +438,21 @@ describe Grape::Validations::ValuesValidator do
     end.to raise_error Grape::Exceptions::IncompatibleOptionValues
   end
 
-  it 'allows values to be true or false when setting the type to boolean' do
-    get('/values/optional_boolean', type: true)
-    expect(last_response.status).to eq 200
-    expect(last_response.body).to eq({ type: true }.to_json)
+  context 'boolean values' do
+    it 'allows a value from the list' do
+      get('/values/optional_boolean', type: true)
+
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq({ type: true }.to_json)
+    end
+
+    it 'rejects a value which is not in the list' do
+      get('/values/optional_boolean', type: false)
+
+      expect(last_response.body).to eq({ error: 'type does not have a valid value' }.to_json)
+    end
   end
+
   it 'allows values to be a kind of the coerced type not just an instance of it' do
     get('/values/coercion', type: 10)
     expect(last_response.status).to eq 200
@@ -462,6 +479,14 @@ describe Grape::Validations::ValuesValidator do
     end.to raise_error Grape::Exceptions::IncompatibleOptionValues
   end
 
+  it 'allows a blank value when the allow_blank option is true' do
+    get 'allow_blank', name: nil
+    expect(last_response.status).to eq(200)
+
+    get 'allow_blank', name: ''
+    expect(last_response.status).to eq(200)
+  end
+
   context 'with a lambda values' do
     subject do
       Class.new(Grape::API) do

data/spec/grape/validations_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations do
@@ -9,14 +11,17 @@ describe Grape::Validations do
 
   describe 'params' do
     context 'optional' do
-      it 'validates when params is present' do
+      before do
         subject.params do
           optional :a_number, regexp: /^[0-9]+$/
+          optional :attachment, type: File
         end
         subject.get '/optional' do
           'optional works!'
         end
+      end
 
+      it 'validates when params is present' do
         get '/optional', a_number: 'string'
         expect(last_response.status).to eq(400)
         expect(last_response.body).to eq('a_number is invalid')
@@ -27,14 +32,7 @@ describe Grape::Validations do
       end
 
       it "doesn't validate when param not present" do
-        subject.params do
-          optional :a_number, regexp: /^[0-9]+$/
-        end
-        subject.get '/optional' do
-          'optional works!'
-        end
-
-        get '/optional'
+        get '/optional', a_number: nil, attachment: nil
         expect(last_response.status).to eq(200)
         expect(last_response.body).to eq('optional works!')
       end
@@ -120,6 +118,62 @@ describe Grape::Validations do
       end
     end
 
+    context 'requires with nested params' do
+      before do
+        subject.params do
+          requires :first_level, type: Hash do
+            optional :second_level, type: Array do
+              requires :value, type: Integer
+              optional :name, type: String
+              optional :third_level, type: Array do
+                requires :value, type: Integer
+                optional :name, type: String
+                optional :fourth_level, type: Array do
+                  requires :value, type: Integer
+                  optional :name, type: String
+                end
+              end
+            end
+          end
+        end
+        subject.put('/required') { 'required works' }
+      end
+
+      let(:request_params) do
+        {
+          first_level: {
+            second_level: [
+              { value: 1, name: 'Lisa' },
+              {
+                value: 2,
+                name: 'James',
+                third_level: [
+                  { value: 'three', name: 'Sophie' },
+                  {
+                    value: 4,
+                    name: 'Jenny',
+                    fourth_level: [
+                      { name: 'Samuel' }, { value: 6, name: 'Jane' }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      end
+
+      it 'validates correctly in deep nested params' do
+        put '/required', request_params.to_json, 'CONTENT_TYPE' => 'application/json'
+
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq(
+          'first_level[second_level][1][third_level][0][value] is invalid, ' \
+          'first_level[second_level][1][third_level][1][fourth_level][0][value] is missing'
+        )
+      end
+    end
+
     context 'requires :all using Grape::Entity documentation' do
       def define_requires_all
         documentation = {
@@ -436,7 +490,7 @@ describe Grape::Validations do
           class DateRangeValidator < Grape::Validations::Base
             def validate_param!(attr_name, params)
               return if params[attr_name][:from] <= params[attr_name][:to]
-              raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: "'from' must be lower or equal to 'to'"
+              raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: "'from' must be lower or equal to 'to'")
             end
           end
         end
@@ -851,7 +905,7 @@ describe Grape::Validations do
         class Customvalidator < Grape::Validations::Base
           def validate_param!(attr_name, params)
             return if params[attr_name] == 'im custom'
-            raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: 'is not custom!'
+            raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: 'is not custom!')
           end
         end
       end
@@ -999,7 +1053,7 @@ describe Grape::Validations do
           class CustomvalidatorWithOptions < Grape::Validations::Base
             def validate_param!(attr_name, params)
               return if params[attr_name] == @option[:text]
-              raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: message
+              raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message)
             end
           end
         end
@@ -1364,7 +1418,7 @@ describe Grape::Validations do
           it 'errors when two or more are present' do
             get '/custom_message/exactly_one_of', beer: 'string', wine: 'anotherstring'
             expect(last_response.status).to eq(400)
-            expect(last_response.body).to eq 'beer, wine, juice are missing, exactly one parameter is required'
+            expect(last_response.body).to eq 'beer, wine are missing, exactly one parameter is required'
           end
         end
 
@@ -1383,7 +1437,7 @@ describe Grape::Validations do
         it 'errors when two or more are present' do
           get '/exactly_one_of', beer: 'string', wine: 'anotherstring'
           expect(last_response.status).to eq(400)
-          expect(last_response.body).to eq 'beer, wine, juice are missing, exactly one parameter must be provided'
+          expect(last_response.body).to eq 'beer, wine are mutually exclusive'
         end
       end
 
@@ -1423,7 +1477,7 @@ describe Grape::Validations do
         it 'errors when two or more are present' do
           get '/exactly_one_of_nested', nested: { beer_nested: 'string' }, nested2: [{ beer_nested2: 'string', wine_nested2: 'anotherstring' }]
           expect(last_response.status).to eq(400)
-          expect(last_response.body).to eq 'nested2[0][beer_nested2], nested2[0][wine_nested2], nested2[0][juice_nested2] are missing, exactly one parameter must be provided'
+          expect(last_response.body).to eq 'nested2[0][beer_nested2], nested2[0][wine_nested2] are mutually exclusive'
         end
       end
     end

data/spec/integration/multi_json/json_spec.rb

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

data/spec/integration/multi_xml/xml_spec.rb

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

data/spec/shared/versioning_examples.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 shared_examples_for 'versioning' do
   it 'sets the API version' do
     subject.format :txt