grape 1.1.0 → 1.7.1

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

@@ -1,10 +1,11 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+describe Grape::Validations::Validators::ValuesValidator do
+  let_it_be(:values_model) do
+    Class.new do
+      DEFAULT_VALUES = %w[valid-type1 valid-type2 valid-type3].freeze
+      DEFAULT_EXCEPTS = %w[invalid-type1 invalid-type2 invalid-type3].freeze
 
-describe Grape::Validations::ValuesValidator do
-  module ValidationsSpec
-    class ValuesModel
-      DEFAULT_VALUES = ['valid-type1', 'valid-type2', 'valid-type3'].freeze
-      DEFAULT_EXCEPTS = ['invalid-type1', 'invalid-type2', 'invalid-type3'].freeze
       class << self
         def values
           @values ||= []
@@ -25,209 +26,226 @@ describe Grape::Validations::ValuesValidator do
           @excepts ||= []
           @excepts << except
         end
+
+        def include?(value)
+          values.include?(value)
+        end
       end
     end
+  end
 
-    module ValuesValidatorSpec
-      class API < Grape::API
-        default_format :json
-
-        resources :custom_message do
-          params do
-            requires :type, values: { value: ValuesModel.values, message: 'value does not include in values' }
-          end
-          get '/' do
-            { type: params[:type] }
-          end
-
-          params do
-            optional :type, values: { value: -> { ValuesModel.values }, message: 'value does not include in values' }, default: 'valid-type2'
-          end
-          get '/lambda' do
-            { type: params[:type] }
-          end
-
-          params do
-            requires :type, values: { except: ValuesModel.excepts, except_message: 'value is on exclusions list', message: 'default exclude message' }
-          end
-          get '/exclude/exclude_message'
-
-          params do
-            requires :type, values: { except: -> { ValuesModel.excepts }, except_message: 'value is on exclusions list' }
-          end
-          get '/exclude/lambda/exclude_message'
-
-          params do
-            requires :type, values: { except: ValuesModel.excepts, message: 'default exclude message' }
-          end
-          get '/exclude/fallback_message'
-        end
+  before do
+    stub_const('ValuesModel', values_model)
+  end
+
+  let_it_be(:app) do
+    ValuesModel = values_model
+    Class.new(Grape::API) do
+      default_format :json
 
+      resources :custom_message do
         params do
-          requires :type, values: ValuesModel.values
+          requires :type, values: { value: ValuesModel.values, message: 'value does not include in values' }
         end
         get '/' do
           { type: params[:type] }
         end
 
         params do
-          requires :type, values: []
-        end
-        get '/empty'
-
-        params do
-          optional :type, values: { value: ValuesModel.values }, default: 'valid-type2'
+          optional :type, values: { value: -> { ValuesModel.values }, message: 'value does not include in values' }, default: 'valid-type2'
         end
-        get '/default/hash/valid' do
+        get '/lambda' do
           { type: params[:type] }
         end
 
         params do
-          optional :type, values: ValuesModel.values, default: 'valid-type2'
-        end
-        get '/default/valid' do
-          { type: params[:type] }
+          requires :type, values: { except: ValuesModel.excepts, except_message: 'value is on exclusions list', message: 'default exclude message' }
         end
+        get '/exclude/exclude_message'
 
         params do
-          optional :type, values: { except: ValuesModel.excepts }, default: 'valid-type2'
-        end
-        get '/default/except' do
-          { type: params[:type] }
+          requires :type, values: { except: -> { ValuesModel.excepts }, except_message: 'value is on exclusions list' }
         end
+        get '/exclude/lambda/exclude_message'
 
         params do
-          optional :type, values: -> { ValuesModel.values }, default: 'valid-type2'
-        end
-        get '/lambda' do
-          { type: params[:type] }
+          requires :type, values: { except: ValuesModel.excepts, message: 'default exclude message' }
         end
+        get '/exclude/fallback_message'
+      end
 
-        params do
-          requires :type, values: ->(v) { ValuesModel.values.include? v }
-        end
-        get '/lambda_val' do
-          { type: params[:type] }
-        end
+      params do
+        requires :type, values: ValuesModel.values
+      end
+      get '/' do
+        { type: params[:type] }
+      end
 
-        params do
-          requires :number, type: Integer, values: ->(v) { v > 0 }
-        end
-        get '/lambda_int_val' do
-          { number: params[:number] }
-        end
+      params do
+        requires :type, values: []
+      end
+      get '/empty'
 
-        params do
-          requires :type, values: -> { [] }
-        end
-        get '/empty_lambda'
+      params do
+        optional :type, values: { value: ValuesModel.values }, default: 'valid-type2'
+      end
+      get '/default/hash/valid' do
+        { type: params[:type] }
+      end
 
-        params do
-          optional :type, values: ValuesModel.values, default: -> { ValuesModel.values.sample }
-        end
-        get '/default_lambda' do
-          { type: params[:type] }
-        end
+      params do
+        optional :type, values: ValuesModel.values, default: 'valid-type2'
+      end
+      get '/default/valid' do
+        { type: params[:type] }
+      end
 
-        params do
-          optional :type, values: -> { ValuesModel.values }, default: -> { ValuesModel.values.sample }
-        end
-        get '/default_and_values_lambda' do
-          { type: params[:type] }
-        end
+      params do
+        optional :type, values: { except: ValuesModel.excepts }, default: 'valid-type2'
+      end
+      get '/default/except' do
+        { type: params[:type] }
+      end
 
-        params do
-          optional :type, type: Boolean, desc: 'A boolean', values: [true]
-        end
-        get '/values/optional_boolean' do
-          { type: params[:type] }
-        end
+      params do
+        optional :type, values: -> { ValuesModel.values }, default: 'valid-type2'
+      end
+      get '/lambda' do
+        { type: params[:type] }
+      end
 
-        params do
-          requires :type, type: Integer, desc: 'An integer', values: [10, 11], default: 10
-        end
-        get '/values/coercion' do
-          { type: params[:type] }
-        end
+      params do
+        optional :type, type: Integer, values: 1..
+      end
+      get '/endless' do
+        { type: params[:type] }
+      end
 
-        params do
-          requires :type, type: Array[Integer], desc: 'An integer', values: [10, 11], default: 10
-        end
-        get '/values/array_coercion' do
-          { type: params[:type] }
-        end
+      params do
+        requires :type, values: ->(v) { ValuesModel.include? v }
+      end
+      get '/lambda_val' do
+        { type: params[:type] }
+      end
 
-        params do
-          optional :optional, type: Array do
-            requires :type, values: %w[a b]
-          end
-        end
-        get '/optional_with_required_values'
+      params do
+        requires :number, type: Integer, values: ->(v) { v > 0 }
+      end
+      get '/lambda_int_val' do
+        { number: params[:number] }
+      end
 
-        params do
-          requires :type, values: { except: ValuesModel.excepts }
-        end
-        get '/except/exclusive' do
-          { type: params[:type] }
-        end
+      params do
+        requires :type, values: -> { [] }
+      end
+      get '/empty_lambda'
 
-        params do
-          requires :type, type: String, values: { except: ValuesModel.excepts }
-        end
-        get '/except/exclusive/type' do
-          { type: params[:type] }
-        end
+      params do
+        optional :type, values: ValuesModel.values, default: -> { ValuesModel.values.sample }
+      end
+      get '/default_lambda' do
+        { type: params[:type] }
+      end
 
-        params do
-          requires :type, values: { except: -> { ValuesModel.excepts } }
-        end
-        get '/except/exclusive/lambda' do
-          { type: params[:type] }
-        end
+      params do
+        optional :type, values: -> { ValuesModel.values }, default: -> { ValuesModel.values.sample }
+      end
+      get '/default_and_values_lambda' do
+        { type: params[:type] }
+      end
 
-        params do
-          requires :type, type: String, values: { except: -> { ValuesModel.excepts } }
-        end
-        get '/except/exclusive/lambda/type' do
-          { type: params[:type] }
-        end
+      params do
+        optional :type, type: Grape::API::Boolean, desc: 'A boolean', values: [true]
+      end
+      get '/values/optional_boolean' do
+        { type: params[:type] }
+      end
 
-        params do
-          requires :type, type: Integer, values: { except: -> { [3, 4, 5] } }
-        end
-        get '/except/exclusive/lambda/coercion' do
-          { type: params[:type] }
-        end
+      params do
+        requires :type, type: Integer, desc: 'An integer', values: [10, 11], default: 10
+      end
+      get '/values/coercion' do
+        { type: params[:type] }
+      end
 
-        params do
-          requires :type, type: Integer, values: { value: 1..5, except: [3] }
-        end
-        get '/mixed/value/except' do
-          { type: params[:type] }
-        end
+      params do
+        requires :type, type: Array[Integer], desc: 'An integer', values: [10, 11], default: 10
+      end
+      get '/values/array_coercion' do
+        { type: params[:type] }
+      end
 
-        params do
-          optional :optional, type: Array[String], values: %w[a b c]
+      params do
+        optional :optional, type: Array do
+          requires :type, values: %w[a b]
         end
-        put '/optional_with_array_of_string_values'
+      end
+      get '/optional_with_required_values'
 
-        params do
-          requires :type, values: { proc: ->(v) { ValuesModel.values.include? v } }
-        end
-        get '/proc' do
-          { type: params[:type] }
-        end
+      params do
+        requires :type, values: { except: ValuesModel.excepts }
+      end
+      get '/except/exclusive' do
+        { type: params[:type] }
+      end
 
-        params do
-          requires :type, values: { proc: ->(v) { ValuesModel.values.include? v }, message: 'failed check' }
-        end
-        get '/proc/message'
+      params do
+        requires :type, type: String, values: { except: ValuesModel.excepts }
+      end
+      get '/except/exclusive/type' do
+        { type: params[:type] }
+      end
+
+      params do
+        requires :type, values: { except: -> { ValuesModel.excepts } }
+      end
+      get '/except/exclusive/lambda' do
+        { type: params[:type] }
       end
-    end
-  end
 
-  def app
-    ValidationsSpec::ValuesValidatorSpec::API
+      params do
+        requires :type, type: String, values: { except: -> { ValuesModel.excepts } }
+      end
+      get '/except/exclusive/lambda/type' do
+        { type: params[:type] }
+      end
+
+      params do
+        requires :type, type: Integer, values: { except: -> { [3, 4, 5] } }
+      end
+      get '/except/exclusive/lambda/coercion' do
+        { type: params[:type] }
+      end
+
+      params do
+        requires :type, type: Integer, values: { value: 1..5, except: [3] }
+      end
+      get '/mixed/value/except' do
+        { type: params[:type] }
+      end
+
+      params do
+        optional :optional, type: Array[String], values: %w[a b c]
+      end
+      put '/optional_with_array_of_string_values'
+
+      params do
+        requires :type, values: { proc: ->(v) { ValuesModel.include? v } }
+      end
+      get '/proc' do
+        { type: params[:type] }
+      end
+
+      params do
+        requires :type, values: { proc: ->(v) { ValuesModel.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
 
   context 'with a custom validation message' do
@@ -244,7 +262,7 @@ describe Grape::Validations::ValuesValidator do
     end
 
     it 'validates against values in a proc' do
-      ValidationsSpec::ValuesModel.add_value('valid-type4')
+      ValuesModel.add_value('valid-type4')
 
       get('/custom_message/lambda', type: 'valid-type4')
       expect(last_response.status).to eq 200
@@ -312,7 +330,7 @@ describe Grape::Validations::ValuesValidator do
       expect(last_response.status).to eq 200
     end
 
-    it 'allows for an optional param with a list of values' do
+    it 'accepts for an optional param with a list of values' do
       put('/optional_with_array_of_string_values', optional: nil)
       expect(last_response.status).to eq 200
     end
@@ -343,15 +361,14 @@ describe Grape::Validations::ValuesValidator do
   end
 
   it 'does not validate updated values without proc' do
-    ValidationsSpec::ValuesModel.add_value('valid-type4')
-
+    ValuesModel.add_value('valid-type4')
     get('/', type: 'valid-type4')
     expect(last_response.status).to eq 400
     expect(last_response.body).to eq({ error: 'type does not have a valid value' }.to_json)
   end
 
   it 'validates against values in a proc' do
-    ValidationsSpec::ValuesModel.add_value('valid-type4')
+    ValuesModel.add_value('valid-type4')
 
     get('/lambda', type: 'valid-type4')
     expect(last_response.status).to eq 200
@@ -364,6 +381,18 @@ describe Grape::Validations::ValuesValidator do
     expect(last_response.body).to eq({ error: 'type does not have a valid value' }.to_json)
   end
 
+  it 'validates against values in an endless range', if: ActiveSupport::VERSION::MAJOR >= 6 do
+    get('/endless', type: 10)
+    expect(last_response.status).to eq 200
+    expect(last_response.body).to eq({ type: 10 }.to_json)
+  end
+
+  it 'does not allow an invalid value for a parameter using an endless range', if: ActiveSupport::VERSION::MAJOR >= 6 do
+    get('/endless', type: 0)
+    expect(last_response.status).to eq 400
+    expect(last_response.body).to eq({ error: 'type does not have a valid value' }.to_json)
+  end
+
   it 'does not allow non-numeric string value for int value using lambda' do
     get('/lambda_int_val', number: 'foo')
     expect(last_response.status).to eq 400
@@ -413,29 +442,39 @@ describe Grape::Validations::ValuesValidator do
   it 'raises IncompatibleOptionValues on an invalid default value from proc' do
     subject = Class.new(Grape::API)
     expect do
-      subject.params { optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], default: ValidationsSpec::ValuesModel.values.sample + '_invalid' }
+      subject.params { optional :type, values: %w[valid-type1 valid-type2 valid-type3], default: "#{ValuesModel.values.sample}_invalid" }
     end.to raise_error Grape::Exceptions::IncompatibleOptionValues
   end
 
   it 'raises IncompatibleOptionValues on an invalid default value' do
     subject = Class.new(Grape::API)
     expect do
-      subject.params { optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], default: 'invalid-type' }
+      subject.params { optional :type, values: %w[valid-type1 valid-type2 valid-type3], default: 'invalid-type' }
     end.to raise_error Grape::Exceptions::IncompatibleOptionValues
   end
 
   it 'raises IncompatibleOptionValues when type is incompatible with values array' do
     subject = Class.new(Grape::API)
     expect do
-      subject.params { optional :type, values: ['valid-type1', 'valid-type2', 'valid-type3'], type: Symbol }
+      subject.params { optional :type, values: %w[valid-type1 valid-type2 valid-type3], type: Symbol }
     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 +501,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
@@ -623,9 +670,9 @@ describe Grape::Validations::ValuesValidator do
     end
 
     it 'accepts multiple valid values' do
-      get '/proc', type: ['valid-type1', 'valid-type3']
+      get '/proc', type: %w[valid-type1 valid-type3]
       expect(last_response.status).to eq 200
-      expect(last_response.body).to eq({ type: ['valid-type1', 'valid-type3'] }.to_json)
+      expect(last_response.body).to eq({ type: %w[valid-type1 valid-type3] }.to_json)
     end
 
     it 'rejects a single invalid value' do
@@ -635,7 +682,7 @@ describe Grape::Validations::ValuesValidator do
     end
 
     it 'rejects an invalid value among valid ones' do
-      get '/proc', type: ['valid-type1', 'invalid-type1', 'valid-type3']
+      get '/proc', type: %w[valid-type1 invalid-type1 valid-type3]
       expect(last_response.status).to eq 400
       expect(last_response.body).to eq({ error: 'type does not have a valid value' }.to_json)
     end