grape 1.8.0 → 2.0.0

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

@@ -1,315 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::Validations::Validators::PresenceValidator do
-  subject do
-    Class.new(Grape::API) do
-      format :json
-    end
-  end
-
-  def app
-    subject
-  end
-
-  context 'without validation' do
-    before do
-      subject.resource :bacons do
-        get do
-          'All the bacon'
-        end
-      end
-    end
-
-    it 'does not validate for any params' do
-      get '/bacons'
-      expect(last_response.status).to eq(200)
-      expect(last_response.body).to eq('All the bacon'.to_json)
-    end
-  end
-
-  context 'with a custom validation message' do
-    before do
-      subject.resource :requires do
-        params do
-          requires :email, type: String, allow_blank: { value: false, message: 'has no value' }, regexp: { value: /^\S+$/, message: 'format is invalid' }, message: 'is required'
-        end
-        get do
-          'Hello'
-        end
-      end
-    end
-
-    it 'requires when missing' do
-      get '/requires'
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"email is required, email has no value"}')
-    end
-
-    it 'requires when empty' do
-      get '/requires', email: ''
-      expect(last_response.body).to eq('{"error":"email has no value, email format is invalid"}')
-    end
-
-    it 'valid when set' do
-      get '/requires', email: 'bob@example.com'
-      expect(last_response.status).to eq(200)
-      expect(last_response.body).to eq('Hello'.to_json)
-    end
-  end
-
-  context 'with a required regexp parameter supplied in the POST body' do
-    before do
-      subject.format :json
-      subject.params do
-        requires :id, regexp: /^[0-9]+$/
-      end
-      subject.post do
-        { ret: params[:id] }
-      end
-    end
-
-    it 'validates id' do
-      post '/'
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"id is missing"}')
-
-      io = StringIO.new('{"id" : "a56b"}')
-      post '/', {}, 'rack.input' => io, 'CONTENT_TYPE' => 'application/json', 'CONTENT_LENGTH' => io.length
-      expect(last_response.body).to eq('{"error":"id is invalid"}')
-      expect(last_response.status).to eq(400)
-
-      io = StringIO.new('{"id" : 56}')
-      post '/', {}, 'rack.input' => io, 'CONTENT_TYPE' => 'application/json', 'CONTENT_LENGTH' => io.length
-      expect(last_response.body).to eq('{"ret":56}')
-      expect(last_response.status).to eq(201)
-    end
-  end
-
-  context 'with a required non-empty string' do
-    before do
-      subject.params do
-        requires :email, type: String, allow_blank: false, regexp: /^\S+$/
-      end
-      subject.get do
-        'Hello'
-      end
-    end
-
-    it 'requires when missing' do
-      get '/'
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"email is missing, email is empty"}')
-    end
-
-    it 'requires when empty' do
-      get '/', email: ''
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"email is empty, email is invalid"}')
-    end
-
-    it 'valid when set' do
-      get '/', email: 'bob@example.com'
-      expect(last_response.status).to eq(200)
-      expect(last_response.body).to eq('Hello'.to_json)
-    end
-  end
-
-  context 'with multiple parameters per requires' do
-    before do
-      subject.params do
-        requires :one, :two
-      end
-      subject.get '/single-requires' do
-        'Hello'
-      end
-
-      subject.params do
-        requires :one
-        requires :two
-      end
-      subject.get '/multiple-requires' do
-        'Hello'
-      end
-    end
-
-    it 'validates for all defined params' do
-      get '/single-requires'
-      expect(last_response.status).to eq(400)
-      single_requires_error = last_response.body
-
-      get '/multiple-requires'
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq(single_requires_error)
-    end
-  end
-
-  context 'with required parameters and no type' do
-    before do
-      subject.params do
-        requires :name, :company
-      end
-      subject.get do
-        'Hello'
-      end
-    end
-
-    it 'validates name, company' do
-      get '/'
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"name is missing, company is missing"}')
-
-      get '/', name: 'Bob'
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"company is missing"}')
-
-      get '/', name: 'Bob', company: 'TestCorp'
-      expect(last_response.status).to eq(200)
-      expect(last_response.body).to eq('Hello'.to_json)
-    end
-  end
-
-  context 'with nested parameters' do
-    before do
-      subject.params do
-        requires :user, type: Hash do
-          requires :first_name
-          requires :last_name
-        end
-      end
-      subject.get '/nested' do
-        'Nested'
-      end
-    end
-
-    it 'validates nested parameters' do
-      get '/nested'
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"user is missing, user[first_name] is missing, user[last_name] is missing"}')
-
-      get '/nested', user: { first_name: 'Billy' }
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"user[last_name] is missing"}')
-
-      get '/nested', user: { first_name: 'Billy', last_name: 'Bob' }
-      expect(last_response.status).to eq(200)
-      expect(last_response.body).to eq('Nested'.to_json)
-    end
-  end
-
-  context 'with triply nested required parameters' do
-    before do
-      subject.params do
-        requires :admin, type: Hash do
-          requires :admin_name
-          requires :super, type: Hash do
-            requires :user, type: Hash do
-              requires :first_name
-              requires :last_name
-            end
-          end
-        end
-      end
-      subject.get '/nested_triple' do
-        'Nested triple'
-      end
-    end
-
-    it 'validates triple nested parameters' do
-      get '/nested_triple'
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to include '{"error":"admin is missing'
-
-      get '/nested_triple', user: { first_name: 'Billy' }
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to include '{"error":"admin is missing'
-
-      get '/nested_triple', admin: { super: { first_name: 'Billy' } }
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"admin[admin_name] is missing, admin[super][user] is missing, admin[super][user][first_name] is missing, admin[super][user][last_name] is missing"}')
-
-      get '/nested_triple', super: { user: { first_name: 'Billy', last_name: 'Bob' } }
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to include '{"error":"admin is missing'
-
-      get '/nested_triple', admin: { super: { user: { first_name: 'Billy' } } }
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"admin[admin_name] is missing, admin[super][user][last_name] is missing"}')
-
-      get '/nested_triple', admin: { admin_name: 'admin', super: { user: { first_name: 'Billy' } } }
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"admin[super][user][last_name] is missing"}')
-
-      get '/nested_triple', admin: { admin_name: 'admin', super: { user: { first_name: 'Billy', last_name: 'Bob' } } }
-      expect(last_response.status).to eq(200)
-      expect(last_response.body).to eq('Nested triple'.to_json)
-    end
-  end
-
-  context 'with reused parameter documentation once required and once optional' do
-    before do
-      docs = { name: { type: String, desc: 'some name' } }
-
-      subject.params do
-        requires :all, using: docs
-      end
-      subject.get '/required' do
-        'Hello required'
-      end
-
-      subject.params do
-        optional :all, using: docs
-      end
-      subject.get '/optional' do
-        'Hello optional'
-      end
-    end
-
-    it 'works with required' do
-      get '/required'
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"name is missing"}')
-
-      get '/required', name: 'Bob'
-      expect(last_response.status).to eq(200)
-      expect(last_response.body).to eq('Hello required'.to_json)
-    end
-
-    it 'works with optional' do
-      get '/optional'
-      expect(last_response.status).to eq(200)
-      expect(last_response.body).to eq('Hello optional'.to_json)
-
-      get '/optional', name: 'Bob'
-      expect(last_response.status).to eq(200)
-      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,161 +0,0 @@
-# frozen_string_literal: true
-
-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: { 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
-
-      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
-
-  context 'custom validation message' do
-    context 'with invalid input' do
-      it 'refuses inapppopriate' do
-        get '/custom_message', name: 'invalid name'
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('{"error":"name format is invalid"}')
-      end
-
-      it 'refuses empty' do
-        get '/custom_message', name: ''
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('{"error":"name format is invalid"}')
-      end
-    end
-
-    it 'accepts nil' do
-      get '/custom_message', name: nil
-      expect(last_response.status).to eq(200)
-    end
-
-    it 'accepts valid input' do
-      get '/custom_message', name: 'bob'
-      expect(last_response.status).to eq(200)
-    end
-
-    context 'regexp with array' do
-      it 'refuses inapppopriate items' do
-        get '/custom_message/regexp_with_array', names: ['invalid name', 'abc']
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('{"error":"names format is invalid"}')
-      end
-
-      it 'refuses empty items' do
-        get '/custom_message/regexp_with_array', names: ['', 'abc']
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('{"error":"names format is invalid"}')
-      end
-
-      it 'refuses nil items' do
-        get '/custom_message/regexp_with_array', names: [nil, 'abc']
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('{"error":"names can\'t be nil"}')
-      end
-
-      it 'accepts valid items' do
-        get '/custom_message/regexp_with_array', names: ['bob']
-        expect(last_response.status).to eq(200)
-      end
-
-      it 'accepts nil instead of array' do
-        get '/custom_message/regexp_with_array', names: nil
-        expect(last_response.status).to eq(200)
-      end
-    end
-  end
-
-  context 'invalid input' do
-    it 'refuses inapppopriate' do
-      get '/', name: 'invalid name'
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"name is invalid"}')
-    end
-
-    it 'refuses empty' do
-      get '/', name: ''
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"name is invalid"}')
-    end
-  end
-
-  it 'accepts nil' do
-    get '/', name: nil
-    expect(last_response.status).to eq(200)
-  end
-
-  it 'accepts valid input' do
-    get '/', name: 'bob'
-    expect(last_response.status).to eq(200)
-  end
-
-  context 'regexp with array' do
-    it 'refuses inapppopriate items' do
-      get '/regexp_with_array', names: ['invalid name', 'abc']
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"names is invalid"}')
-    end
-
-    it 'refuses empty items' do
-      get '/regexp_with_array', names: ['', 'abc']
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"names is invalid"}')
-    end
-
-    it 'refuses nil items' do
-      get '/regexp_with_array', names: [nil, 'abc']
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"names is invalid"}')
-    end
-
-    it 'accepts valid items' do
-      get '/regexp_with_array', names: ['bob']
-      expect(last_response.status).to eq(200)
-    end
-
-    it 'accepts nil instead of array' do
-      get '/regexp_with_array', names: nil
-      expect(last_response.status).to eq(200)
-    end
-  end
-
-  context 'nested regexp with array' do
-    it 'refuses inapppopriate' do
-      get '/nested_regexp_with_array', people: 'invalid name'
-      expect(last_response.status).to eq(400)
-      expect(last_response.body).to eq('{"error":"people is invalid, people[names] is missing, people[names] is invalid"}')
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-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
-    end
-  end
-
-  describe '/' do
-    context 'is the same' do
-      it do
-        post '/', password: '987654', password_confirmation: '987654'
-        expect(last_response.status).to eq(201)
-        expect(last_response.body).to eq('')
-      end
-    end
-
-    context 'is not the same' do
-      it do
-        post '/', password: '123456', password_confirmation: 'whatever'
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('password_confirmation is not the same as password')
-      end
-    end
-  end
-
-  describe '/custom-message' do
-    context 'is the same' do
-      it do
-        post '/custom-message', password: '987654', password_confirmation: '987654'
-        expect(last_response.status).to eq(201)
-        expect(last_response.body).to eq('')
-      end
-    end
-
-    context 'is not the same' do
-      it do
-        post '/custom-message', password: '123456', password_confirmation: 'whatever'
-        expect(last_response.status).to eq(400)
-        expect(last_response.body).to eq('password_confirmation not match')
-      end
-    end
-  end
-end