Comment tester que la validation a échoué dans ActiveRecord?

J'ai un modèle comme ceci:

class User < ActiveRecord::Base
  validates_length_of :name, :in => (2..5)
end

Je veux tester cette validation:

it "should not allow too short name" do
  u = User.new(:name => "a")
  u.valid?
  u.should have(1).error_on(:name)
end

Mais il n'y a pas de test quel type d'erreur a été mis sur name. Je veux savoir, si il était too_short, too_long, ou peut-être une autre échec de la validation.

Je peux rechercher le texte du message dans les erreurs de tableau, comme ceci:

u.errors[:name].should include(I18n.t("activerecord.errors.models.user.attributes.name.too_short"))

Mais cela ne fonctionne pas quand je activerecord.errors.messages.too_short dans les paramètres régionaux de fichier au lieu de spécifiques au modèle de message.

Donc est-il possible de vérifier le type d'erreur est survenue?

InformationsquelleAutor Jan Dudek | 2010-11-07
  1. 39

    Rails ajout d'une méthode de requête pour les erreurs de ActiveModel à la fin de 2011 et les Rails de la v3.2. Il suffit de vérifier pour voir si l'erreur a été #ajouté?:

    # An error added manually
record.errors.add :name, :blank
record.errors.added? :name, :blank # => true

# An error added after validation
record.email = '[email protected]'
record.valid? # => false
record.errors.added? :email, :taken # => true

    Noter que pour les validations qui sont paramétrées (par exemple :greater_than_or_equal_to), vous aurez besoin de transmettre la valeur du paramètre trop.

    record.errors.add(:age, :greater_than_or_equal_to, count: 1)
record.errors.added?(:age, :greater_than_or_equal_to, count: 1)

    Les erreurs sont identifiées par leur clé i18n. Vous pouvez trouver les touches appropriées pour vérifier dans la Rails i18n fichier pour n'importe quelle langue, en vertu de la section erreur.

    Quelques sympathiques questions que vous pouvez poser ActiveModel#Error sont #vide? et
    #inclure?(attr), ainsi que tout ce que vous pouvez demander à un Énumérable.

    • ajoutée? est une méthode pratique. Combiné avec rspec syntaxe de ce qui pourrait faire qu'il se lit vraiment très bien. E. g. expect(record.errors).to be_added :name, :blank
    • Remarque, vous avez besoin pour passer des options comme le troisième paramètre pour quelques vérifications. par exemple, assert record.errors.added?(:slug, :too_short, count: 5) où 5 correspond à la longueur requise.
    • Notez que cette solution ne fonctionne que pour le modèle de validation. L'ajout d'arbitraire erreurs ne peut pas être vérifiée avec #added? Par exemple, #added? renvoie une erreur si la vérification d'une erreur si :name ou :email dans l'exemple ci-dessus n'est pas un attribut du modèle.
    • Malheureusement added? est encore en train de faire des messages d'erreur de comparaison de chaîne sous le capot. Cela signifie que nous avons à passer dans l'interpolation de la valeur pour que cela fonctionne: github.com/rails/rails/pull/14067/files#r9781601 qui est un peu ennuyeux.
    InformationsquelleAutor fny
  2. 12

    Je n'aime vraiment pas l'idée de la recherche de traduire les messages d'erreur dans les Erreurs de hachage. Après une conversation avec un autre Rubyists, j'ai fini monkey patching Erreurs de hachage, de sorte qu'il économise de la non-traduction du message en premier.

    module ActiveModel
  class Errors
    def error_names
      @_error_names ||= { }
    end

    def add_with_save_names(attribute, message = nil, options = {})
      message ||= :invalid
      if message.is_a?(Proc)
        message = message.call
      end
      error_names[attribute] ||= []
      error_names[attribute] << message
      add_without_save_names(attribute, message, options)
    end

    alias_method_chain :add, :save_names
  end
end

    Alors vous pouvez tester comme ceci:

    u = User.new(:name => "a")
u.valid?
u.errors.error_names[:name].should include(:too_short)
    • Rails totalement ce faire .. si elle a des types de validation, le fait qu'ils ne persistent grâce à l'erreur de l'objet est bizarre et frustrant.
    • Cette réponse est un peu dépassé. Rails v3.2 offre cette possibilité via Error#added?. Voir ma réponse pour plus d'info.
    • c'est génial. ne peux pas croire que je ne pouvais pas trouver que. Merci!
    • Je voudrais éviter de n'importe quel singe patchs. Rails 5: person = Person.new person.validate person.errors.details[:name] # => [{error: :blank}] Rails 4-port: github.com/cowbell/active_model-errors_details
    InformationsquelleAutor Jan Dudek
  3. 5

    Je vous recommandons de vérifier la gemme shoulda pour le traitement de ces types de répétitif des tests de validation. Il complète RSpec ou de Test::Unit de sorte que vous pouvez écrire concis spécifications telles que:

    describe User do
  it { should ensure_length_of(:name).is_at_least(2).is_at_most(5) }
end
    • Simplement en regardant le code pour cela, on dirait qu'il a juste l'air pour la traduction des messages trop. Regarde bien quand même, et au moins de cette façon, le code est maintenu dans le cadre d'une bibliothèque, non pas comme une partie de l'application.
    • Merci pour vos réponses. Mon objectif était de tester une validation plus complexe scénario, donc je n'ai pas envie d'utiliser aurais dû. Je suppose que si shoulda fonctionne de cette façon, il n'y a pas d'autre moyen de vérifier que la validation a échoué.
    InformationsquelleAutor Peter Brown
  4. 5

    L'approche que j'ai utiliser: 

    it "should not allow too short name" do
  u = User.new(:name => "a")
  expect{u.save!}.to raise_exception(/Name is too short/)
end

    - Je utiliser une expression régulière pour rechercher le message d'exception car il peut y avoir beaucoup de messages de validation dans le message de l'exception, mais nous voulons nous assurer qu'il contiennent un extrait concernant le nom étant trop court.

    Cette approche ne couple vos affirmations pour vos messages de validation, donc si vous tous de modifier votre message de validation, vous aurez probablement besoin de modifier vos spécifications ainsi. Mais dans l'ensemble, c'est un moyen simple de faire valoir les validations sont en train de faire leur travail.

    • Mais cela permet d'économiser de l'enregistrement si le test échoue. D'autres effets secondaires peuvent également se produire. Pourquoi ne pas utiliser valide? pour vous assurer que vous êtes juste des tests de validation?
    InformationsquelleAutor Ben5e