RSpec: Correspond à un tableau de chaînes par regex

Je suis en train de tester la validation de mes modèles avec rspec et suis dans l'attente d'un message d'erreur. Cependant, le texte exact du message est susceptible de changer, donc je veux être un peu plus indulgent et seulement une partie du message.

Depuis le Spec::les allumettes::il y a la méthode ne fonctionne que pour les cordes et les collections, je suis actuellement à l'aide de cette construction:

@user.errors[:password].any?{|m|m.match(/is too short/)}.should be_true

Cela fonctionne, mais semble un peu lourd pour moi. Est-il mieux (c'est à dire, plus rapide ou le plus proche de ruby) pour vérifier un tableau pour l'inclusion d'une chaîne en regex, ou peut-être un rspec comparateur de qui est-ce?

source d'informationauteur Thilo

Je recommanderais de faire

@user.errors[:password].to_s.should =~ /is too short/

Tout simplement parce qu'il vous donnera une erreur plus utile lorsqu'il échoue. Si vous utilisez be_any ensuite, vous obtenez un message comme ça...

Failure/Error: @user.errors[:password].should be_any{ |m| m =~ /is too short/}
    expected any? to return true, got false

Toutefois, si vous utilisez le to_s méthode, puis vous obtiendrez quelque chose comme ceci:

 Failure/Error: @user.errors[:password].to_s.should =~ /is too short/
   expected: /is to short/
        got: "[]" (using =~)
   Diff:
   @@ -1,2 +1,2 @@
   -/is too short/
   +"[]"

De sorte que vous pouvez voir la raison de l'échec et de ne pas avoir à aller creuser beaucoup pour comprendre pourquoi c'est un échec.

Vous pouvez mettre le code suivant dans spec/support/custom_matchers.rb

RSpec::Matchers.define :include_regex do |regex|
  match do |actual|
    actual.find { |str| str =~ regex }
  end
end

Maintenant, vous pouvez l'utiliser comme ceci:

@user.errors.should include_regex(/is_too_short/)

et assurez-vous d'avoir quelque chose comme ceci dans spec/spec_helper.rb.rb

Dir[Rails.root.join("spec/support/**/*.rb")].each {|f| require f}

8

Je ne pense pas que cela fait une différence en termes de performances, mais plus RSpec-comme solution serait
```
@user.errors[:password].should be_any { |m| m =~ /is too short/ }
```

À l'aide de RSpec 3 attendre syntaxe avec les allumettes de la composition:

Pour correspondre à tous:

expect(@user.errors[:password]).to all(match /some message/)

Pour correspondre à tout:

expect(@user.errors[:password]).to include(match /some message/)
expect(@user.errors[:password]).to include a_string_matching /some message/

6

À la fois la réponse ci-dessus sont bonnes. Je voudrais, toutefois, utiliser la plus récente Rspec expect syntaxe
```
@user.errors[:password].to_s.should =~ /is too short/
```
devient
```
expect(@user.errors[:password].to_s).to match(/is too short/)
```
Plus d'info ici: http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
2

Ma solution à ce problème est similaire à @muirbot. J'utilise une correspondance personnalisée. Cependant, j'utilise le réel include matcher, mais l'augmenter avec la correspondance personnalisée comme argument. Charge ce, quelque part avant votre suite s'exécute (par exemple dans les spec/support/de rapprochement.rb, à son tour chargé par spec/spec_helper.rb.rb):
```
RSpec::Matchers.define(:a_string_matching) do |expected|
  match do |actual|
    actual =~ expected
  end
end
```
Alors votre attente peut être écrit comme ceci:
```
expect(@user.errors[:password]).to include(a_string_matching(/is too short/))
```

Juste une autre option

@user.errors[:password].grep /is too short/

Vous devez vous connecter pour publier un commentaire.