grape 1.6.0 → 1.6.2

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

@@ -2,53 +2,47 @@
 
 require 'spec_helper'
 
-describe Grape::Validations::RegexpValidator do
-  module ValidationsSpec
-    module RegexpValidatorSpec
-      class API < Grape::API
-        default_format :json
-
-        resources :custom_message do
-          params do
-            requires :name, regexp: { value: /^[a-z]+$/, message: 'format is invalid' }
-          end
-          get do
-          end
-
-          params do
-            requires :names, type: { value: Array[String], message: 'can\'t be nil' }, regexp: { value: /^[a-z]+$/, message: 'format is invalid' }
-          end
-          get 'regexp_with_array' do
-          end
-        end
+describe Grape::Validations::Validators::RegexpValidator do
+  let_it_be(:app) do
+    Class.new(Grape::API) do
+      default_format :json
 
+      resources :custom_message do
         params do
-          requires :name, regexp: /^[a-z]+$/
+          requires :name, regexp: { value: /^[a-z]+$/, message: 'format is invalid' }
         end
         get do
         end
 
         params do
-          requires :names, type: Array[String], regexp: /^[a-z]+$/
+          requires :names, type: { value: Array[String], message: 'can\'t be nil' }, regexp: { value: /^[a-z]+$/, message: 'format is invalid' }
         end
         get 'regexp_with_array' do
         end
+      end
 
-        params do
-          requires :people, type: Hash do
-            requires :names, type: Array[String], regexp: /^[a-z]+$/
-          end
-        end
-        get 'nested_regexp_with_array' do
+      params do
+        requires :name, regexp: /^[a-z]+$/
+      end
+      get do
+      end
+
+      params do
+        requires :names, type: Array[String], regexp: /^[a-z]+$/
+      end
+      get 'regexp_with_array' do
+      end
+
+      params do
+        requires :people, type: Hash do
+          requires :names, type: Array[String], regexp: /^[a-z]+$/
         end
       end
+      get 'nested_regexp_with_array' do
+      end
     end
   end
 
-  def app
-    ValidationsSpec::RegexpValidatorSpec::API
-  end
-
   context 'custom validation message' do
     context 'with invalid input' do
       it 'refuses inapppopriate' do

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

@@ -2,31 +2,25 @@
 
 require 'spec_helper'
 
-describe Grape::Validations::SameAsValidator do
-  module ValidationsSpec
-    module SameAsValidatorSpec
-      class API < Grape::API
-        params do
-          requires :password
-          requires :password_confirmation, same_as: :password
-        end
-        post do
-        end
+describe Grape::Validations::Validators::SameAsValidator do
+  let_it_be(:app) do
+    Class.new(Grape::API) do
+      params do
+        requires :password
+        requires :password_confirmation, same_as: :password
+      end
+      post do
+      end
 
-        params do
-          requires :password
-          requires :password_confirmation, same_as: { value: :password, message: 'not match' }
-        end
-        post '/custom-message' do
-        end
+      params do
+        requires :password
+        requires :password_confirmation, same_as: { value: :password, message: 'not match' }
+      end
+      post '/custom-message' do
       end
     end
   end
 
-  def app
-    ValidationsSpec::SameAsValidatorSpec::API
-  end
-
   describe '/' do
     context 'is the same' do
       it do

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

@@ -2,11 +2,12 @@
 
 require 'spec_helper'
 
-describe Grape::Validations::ValuesValidator do
-  module ValidationsSpec
-    class ValuesModel
+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
+
       class << self
         def values
           @values ||= []
@@ -33,212 +34,213 @@ describe Grape::Validations::ValuesValidator do
         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: []
+          optional :type, values: { value: -> { ValuesModel.values }, message: 'value does not include in values' }, default: 'valid-type2'
         end
-        get '/empty'
-
-        params do
-          optional :type, values: { value: ValuesModel.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.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
+        requires :type, values: ->(v) { ValuesModel.include? v }
+      end
+      get '/lambda_val' 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 :number, type: Integer, values: ->(v) { v > 0 }
+      end
+      get '/lambda_int_val' do
+        { number: params[:number] }
+      end
 
-        params do
-          optional :optional, type: Array do
-            requires :type, values: %w[a b]
-          end
-        end
-        get '/optional_with_required_values'
+      params do
+        requires :type, values: -> { [] }
+      end
+      get '/empty_lambda'
 
-        params do
-          requires :type, values: { except: ValuesModel.excepts }
-        end
-        get '/except/exclusive' 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, 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_and_values_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, type: Grape::API::Boolean, desc: 'A boolean', values: [true]
+      end
+      get '/values/optional_boolean' 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
+        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: { except: -> { [3, 4, 5] } }
-        end
-        get '/except/exclusive/lambda/coercion' 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, type: Integer, values: { value: 1..5, except: [3] }
-        end
-        get '/mixed/value/except' do
-          { type: params[:type] }
+      params do
+        optional :optional, type: Array do
+          requires :type, values: %w[a b]
         end
+      end
+      get '/optional_with_required_values'
 
-        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: { except: ValuesModel.excepts }
+      end
+      get '/except/exclusive' do
+        { type: params[:type] }
+      end
 
-        params do
-          requires :type, values: { proc: ->(v) { ValuesModel.include? v } }
-        end
-        get '/proc' do
-          { type: params[:type] }
-        end
+      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: { proc: ->(v) { ValuesModel.include? v }, message: 'failed check' }
-        end
-        get '/proc/message'
+      params do
+        requires :type, values: { except: -> { ValuesModel.excepts } }
+      end
+      get '/except/exclusive/lambda' do
+        { type: params[:type] }
+      end
 
-        params do
-          optional :name, type: String, values: %w[a b], allow_blank: true
-        end
-        get '/allow_blank'
+      params do
+        requires :type, type: String, values: { except: -> { ValuesModel.excepts } }
+      end
+      get '/except/exclusive/lambda/type' do
+        { type: params[:type] }
       end
-    end
-  end
 
-  def app
-    ValidationsSpec::ValuesValidatorSpec::API
+      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
@@ -255,7 +257,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
@@ -354,15 +356,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
@@ -424,7 +425,7 @@ 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: %w[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