[RUBY] Comment valider les tests suivants même si le test échoue

introduction

Parfois, vous voudrez peut-être mettre plusieurs «exemples» dans un «it». Si vous ajoutez simplement plusieurs «exemples», le test suivant ne se déroulera pas lorsque le test échoue, et ** Réparez le test échoué → Échec du test suivant → Corrigez le test échoué ** Répétez C'est gênant. Dans un tel cas, vous pouvez le résoudre en spécifiant ʻaggregate_failures`.

Qu'est-ce que aggregate_failures

En regardant la documentation officielle (https://relishapp.com/rspec/rspec-expectations/docs/aggregating-failures), il explique:

RSpec::Expectations provides aggregate_failures, an API that allows you to group a set of expectations and see all the failures at once, rather than it aborting on the first failure.

En d'autres termes, en spécifiant ʻaggregate_failures`, vous pouvez valider les tests suivants même si le test échoue. Je pense qu'il est plus rapide de voir le comportement, alors j'aimerais l'essayer immédiatement.

Si vous n'utilisez pas aggregate_failures

Vérifions avec le code suivant.

require 'spec_helper'

RSpec.describe 'hoge spec' do
  it 'Être un hoge' do
    expect(1).to eq(2)
    expect(1).to eq(3)
  end
end

Lorsque j'ai exécuté le test, le résultat était le suivant.

hoge spec
Être un hoge(FAILED - 1)

Failures:

  1)hoge spec pour devenir hoge
     Failure/Error: expect(1).to eq(2)

       expected: 2
            got: 1

       (compared using ==)
     # ./spec/hoge_spec.rb:5:in `block (2 levels) in <top (required)>'

Top 1 slowest examples (0.0273 seconds, 89.2% of total time):
hoge spec pour devenir hoge
    0.0273 seconds ./spec/hoge_spec.rb:4

Finished in 0.0306 seconds (files took 0.23906 seconds to load)
1 example, 1 failure

Failed examples:

rspec ./spec/hoge_spec.rb:4 #hoge spec pour devenir hoge

En regardant les résultats, nous pouvons voir qu'après l'échec du premier «attendu», le deuxième «attendu» n'a pas été validé.

Lors de l'utilisation de aggregate_failures

Ensuite, spécifiez ʻaggregate_failures` comme indiqué ci-dessous et exécutez-le.

require 'spec_helper'

RSpec.describe 'hoge spec' do
  it 'Être un hoge' do
    aggregate_failures do
      expect(1).to eq(2)
      expect(1).to eq(3)
    end
  end
end

Le résultat ressemble à ceci.

hoge spec
Être un hoge(FAILED - 1)

Failures:

  1)hoge spec pour devenir hoge
     Got 2 failures from failure aggregation block.
     # ./spec/hoge_spec.rb:5:in `block (2 levels) in <top (required)>'

     1.1) Failure/Error: expect(1).to eq(2)

            expected: 2
                 got: 1

            (compared using ==)
          # ./spec/hoge_spec.rb:6:in `block (3 levels) in <top (required)>'

     1.2) Failure/Error: expect(1).to eq(3)

            expected: 3
                 got: 1

            (compared using ==)
          # ./spec/hoge_spec.rb:7:in `block (3 levels) in <top (required)>'

Top 1 slowest examples (0.0255 seconds, 90.1% of total time):
hoge spec pour devenir hoge
    0.0255 seconds ./spec/hoge_spec.rb:4

Finished in 0.0283 seconds (files took 0.23094 seconds to load)
1 example, 1 failure

Failed examples:

rspec ./spec/hoge_spec.rb:4 #hoge spec pour devenir hoge

Apparemment, le premier «attendu» échoue de la même manière, mais le second «attendu» est également vérifié.

Comment spécifier aggregate_failures

A présent, nous savons que la spécification de ʻaggregate_failures validera les tests suivants même si le test échoue. Il y a plusieurs façons de spécifier ʻaggregate_failures, donc à partir de là, nous verrons comment spécifier chacun d'eux.

Comment spécifier en blocs

Comme mentionné précédemment, il s'agit d'une spécification de bloc.

require 'spec_helper'

RSpec.describe 'hoge spec' do
  it 'Être un hoge' do
    aggregate_failures do
      expect(1).to eq(2)
      expect(1).to eq(3)
    end
  end
end

Comment spécifier comme méta-information

Voici comment le spécifier comme méta-information de ʻit`.

require 'spec_helper'

RSpec.describe 'hoge spec' do
  it 'Être un hoge', :aggregate_failures do
    expect(1).to eq(2)
    expect(1).to eq(3)
  end
end

Mauvais modèle

Essayez de spécifier ʻaggregate_failures` comme premier argument comme indiqué ci-dessous.

require 'spec_helper'

RSpec.describe 'hoge spec' do
  it :aggregate_failures do
    expect(1).to eq(2)
    expect(1).to eq(3)
  end
end

Cliquez ici pour les résultats.

hoge spec
  aggregate_failures (FAILED - 1)

Failures:

  1) hoge spec aggregate_failures
     Failure/Error: expect(1).to eq(2)

       expected: 2
            got: 1

       (compared using ==)
     # ./spec/hoge_spec.rb:5:in `block (2 levels) in <top (required)>'

Top 1 slowest examples (0.02586 seconds, 89.1% of total time):
  hoge spec aggregate_failures
    0.02586 seconds ./spec/hoge_spec.rb:4

Finished in 0.02902 seconds (files took 0.23787 seconds to load)
1 example, 1 failure

Failed examples:

rspec ./spec/hoge_spec.rb:4 # hoge spec aggregate_failures

Comme vous pouvez le voir dans le résultat, si vous le spécifiez avec le premier argument, le traitement suivant ne se déroule pas, donc le comportement attendu n'est pas obtenu. Même si cela échoue, je ne pense pas que je vérifierai si le traitement ultérieur est en cours, donc c'est difficile à remarquer ...

en conclusion

Nous avons vu le comportement de ʻaggregate_failures` et quelques moyens de le spécifier. Personnellement, je pense que c'est correct car la méthode de spécification avec des blocs semble créer une dépendance. Si vous souhaitez inclure plusieurs «exemples», spécifiez «défauts_agrégats».