ruby on rails - validar - ¿Cómo probar un validador personalizado?

validar campos rails

Question

Tengo el siguiente validador:

# Source: http://guides.rubyonrails.org/active_record_validations_callbacks.html#custom-validators
# app/validators/email_validator.rb
class EmailValidator < ActiveModel::EachValidator
def validate_each(object, attribute, value)
unless value =~ /^([^@/s]+)@((?:[-a-z0-9]+/.)+[a-z]{2,})$/i
object.errors[attribute] << (options[:message] || "is not formatted properly")
end
end
end

Me gustaría poder probar esto en RSpec dentro de mi directorio lib. El problema hasta ahora es que no estoy seguro de cómo inicializar un EachValidator .

Answer 1

Aquí hay una especificación rápida que noqueé para ese archivo y funciona bien. Creo que el trozo probablemente podría limpiarse, pero espero que esto sea suficiente para comenzar.

require ''spec_helper''
describe "EmailValidator" do
before(:each) do
@validator = EmailValidator.new({:attributes => {}})
@mock = mock(''model'')
@mock.stub("errors").and_return([])
@mock.errors.stub(''[]'').and_return({})
@mock.errors[].stub(''<<'')
end
it "should validate valid address" do
@mock.should_not_receive(''errors'')
@validator.validate_each(@mock, "email", "[email protected]")
end
it "should validate invalid address" do
@mock.errors[].should_receive(''<<'')
@validator.validate_each(@mock, "email", "notvalid")
end
end

Answer 2

No soy un gran admirador del otro enfoque porque relaciona la prueba demasiado cerca de la implementación. Además, es bastante difícil de seguir. Este es el enfoque que finalmente uso. Tenga en cuenta que esto es una simplificación excesiva de lo que mi validador realmente hizo ... solo quería demostrarlo de manera más simple. Definitivamente hay optimizaciones para hacerse

class OmniauthValidator < ActiveModel::Validator
def validate(record)
if !record.omniauth_provider.nil? && !%w(facebook github).include?(record.omniauth_provider)
record.errors[:omniauth_provider] << ''Invalid omniauth provider''
end
end
end

Especificación asociada:

require ''spec_helper''
class Validatable
include ActiveModel::Validations
validates_with OmniauthValidator
attr_accessor :omniauth_provider
end
describe OmniauthValidator do
subject { Validatable.new }
context ''without provider'' do
it ''is valid'' do
expect(subject).to be_valid
end
end
context ''with valid provider'' do
it ''is valid'' do
subject.stubs(omniauth_provider: ''facebook'')
expect(subject).to be_valid
end
end
context ''with unused provider'' do
it ''is invalid'' do
subject.stubs(omniauth_provider: ''twitter'')
expect(subject).not_to be_valid
expect(subject).to have(1).error_on(:omniauth_provider)
end
end
end

Básicamente mi enfoque es crear un objeto falso "Validatable" para que podamos probar los resultados en lugar de tener expectativas para cada parte de la implementación.

Answer 3

Recomendaría crear una clase anónima para fines de prueba, como:

require ''spec_helper''
require ''active_model''
require ''email_validator''
RSpec.describe EmailValidator do
subject do
Class.new do
include ActiveModel::Validations
attr_accessor :email
validates :email, email: true
end.new
end
describe ''empty email addresses'' do
['''', nil].each do |email_address|
describe "when email address is #{email_address}" do
it "does not add an error" do
subject.email = email_address
subject.validate
expect(subject.errors[:email]).not_to include ''is not a valid email address''
end
end
end
end
describe ''invalid email addresses'' do
[''nope'', ''@'', ''[email protected].'', ''.'', '' ''].each do |email_address|
describe "when email address is #{email_address}" do
it "adds an error" do
subject.email = email_address
subject.validate
expect(subject.errors[:email]).to include ''is not a valid email address''
end
end
end
end
describe ''valid email addresses'' do
[''[email protected]'', ''[email protected]''].each do |email_address|
describe "when email address is #{email_address}" do
it "does not add an error" do
subject.email = email_address
subject.validate
expect(subject.errors[:email]).not_to include ''is not a valid email address''
end
end
end
end
end

Esto evitará que las clases codificadas como Validatable , que pueden ser referenciadas en múltiples especificaciones, muestren un comportamiento inesperado debido a las interacciones entre validaciones no relacionadas, que usted está tratando de probar de forma aislada.

Answer 4

Un ejemplo más, con la extensión de un objeto en lugar de crear una nueva clase en la especificación. BitcoinAddressValidator es un validador personalizado aquí.

require ''rails_helper''
module BitcoinAddressTest
def self.extended(parent)
class << parent
include ActiveModel::Validations
attr_accessor :address
validates :address, bitcoin_address: true
end
end
end
describe BitcoinAddressValidator do
subject(:model) { Object.new.extend(BitcoinAddressTest) }
it ''has invalid bitcoin address'' do
model.address = ''invalid-bitcoin-address''
expect(model.valid?).to be_falsey
expect(model.errors[:address].size).to eq(1)
end
# ...
end

Answer 5

Utilizando el gran ejemplo de Neals como base, se me ocurrió lo siguiente (para Rails y RSpec 3).

# /spec/lib/slug_validator_spec.rb
require ''rails_helper''
class Validatable
include ActiveModel::Model
include ActiveModel::Validations
attr_accessor :slug
validates :slug, slug: true
end
RSpec.describe SlugValidator do
subject { Validatable.new(slug: slug) }
context ''when the slug is valid'' do
let(:slug) { ''valid'' }
it { is_expected.to be_valid }
end
context ''when the slug is less than the minimum allowable length'' do
let(:slug) { ''v'' }
it { is_expected.to_not be_valid }
end
context ''when the slug is greater than the maximum allowable length'' do
let(:slug) { ''v'' * 64 }
it { is_expected.to_not be_valid }
end
context ''when the slug contains invalid characters'' do
let(:slug) { ''*'' }
it { is_expected.to_not be_valid }
end
context ''when the slug is a reserved word'' do
let(:slug) { ''blog'' }
it { is_expected.to_not be_valid }
end
end