Comprendre la couverture du code avec Rspec, le framework de test Ruby on Rails

Lorsque j'écris un cas de test, j'obtiens une histoire sur la couverture qu'il couvre.

Qu'est-ce que la couverture de code? J'ai pensé, alors je vais le résumer comme mon mémorandum.

Qu'est-ce que la couverture de code?

Lors des tests logiciels, tout le code de programme (logique interne) à tester C'est le rapport (taux de couverture) de la partie du corps qui a été testée. Référence

Couverture typique

C0: Couverture de l'instruction

Chaque instruction est exécutée au moins une fois

C1: Couverture des succursales

Exécuter au moins une fois pour chaque condition de jugement

C2: Couverture de l'état

L'authenticité dans chaque instruction conditionnelle est exécutée au moins une fois

MCC: couverture complète des conditions

Toutes les combinaisons de vérité et de mensonge qui peuvent être placées dans chaque condition sont exécutées

En fait, rédigez des tests en gardant à l'esprit la couverture avec Rspec

Code Ruby à tester

sample.rb

module CodeCoverage
  class << self
  # main
  # @params [interger] x
  # @params [interger] y
  # @return [String]Chaînes de caractères qui diffèrent selon les valeurs de x et y
  #
  #L'argument suppose seulement un entier
  def main(x, y)
    result = ''
    if x >= y || x % 2 == 0
      result << 'Processus 1'
    else
      result << 'Processus 2'
    end
    if x*y > 10
      result << 'Processus 3'
    else
      result << 'Processus 4'
    end
    return result
  end
  end
end

Code de test écrit en Rspec

Qu'est-ce que Rspec

Un des frameworks pour réaliser le TDD (Test Driven Development), qui est l'une des méthodes de développement de Ruby on Rails Référence

Corps du code de test

RSpec.describe CodeCoverage do
  shared_examples 'Processus 1 et processus 3 passes' do
    it 'Le libellé du processus 1 et du processus 3 est renvoyé' do
      expect(subject).to eq 'Processus 1 Processus 3'
    end
  end
  shared_examples 'Processus 1 et processus 4 passes' do
    it 'Le libellé du processus 1 et du processus 4 est renvoyé' do
      expect(subject).to eq 'Processus 1 Processus 4'
    end
  end
  shared_examples 'Processus 2 et processus 3 passes' do
    it 'Le libellé du processus 2 et du processus 3 est renvoyé' do
      expect(subject).to eq 'Processus 2 Processus 3'
    end
  end
  shared_examples 'Processus 2 et processus 4 passes' do
    it 'Le libellé du processus 2 et du processus 4 est retourné' do
      expect(subject).to eq 'Processus 2 Processus 4'
    end
  end

  describe 'main' do
    subject { described_class.send(:main, x, y) }
      # C0:Couverture de l'instruction
　　　 #Écrire pour exécuter au moins une fois avec peu d'instructions
      context 'Pour C0' do
        context 'Passez par le processus 1 et le processus 3' do
          let(:x) { 11 }
          let(:y) { 1 }
          it_behaves_like 'Processus 1 et processus 3 passes'
        end
        context 'Passez par le processus 2 et le processus 4' do
          let(:x) { 1 }
          let(:y) { 9 }
          it_behaves_like 'Processus 2 et processus 4 passes'
        end
      end
      # C1:Couverture des succursales
      #Exécuter au moins une fois pour chaque condition de jugement
      context 'Pour C1' do
        context 'Passez par le processus 1 et le processus 3' do
          let(:x) { 11 }
          let(:y) { 1 }
          it_behaves_like 'Processus 1 et processus 3 passes'
        end
        context 'Passez par le processus 1 et le processus 4' do
          let(:x) { 3 }
          let(:y) { 2 }
          it_behaves_like 'Processus 1 et processus 4 passes'
        end
        context 'Passez par le processus 2 et le processus 3' do
          let(:x) { 3 }
          let(:y) { 5 }
          it_behaves_like 'Processus 2 et processus 3 passes'
        end
        context 'Passez par le processus 2 et le processus 4' do
          let(:x) { 1 }
          let(:y) { 4 }
          it_behaves_like 'Processus 2 et processus 4 passes'
        end
      end
      
      # C2:Couverture de l'état
      #L'authenticité dans chaque instruction conditionnelle est exécutée au moins une fois
      context 'Pour C2' do
        context 'x>=y et x*y>10' do
          context 'Passez par le processus 1 et le processus 3' do
            let(:x) { 11 }
            let(:y) { 1 }
            it_behaves_like 'Processus 1 et processus 3 passes'
          end
        end
        context 'x>=y et x*y<10' do
          context 'Passez par le processus 1 et le processus 4' do
            let(:x) { 3 }
            let(:y) { 2 }
            it_behaves_like 'Processus 1 et processus 4 passes'
          end
        end
        context 'x<y et x sont pairs et x*y>10' do
          context 'Passez par le processus 1 et le processus 3' do
            let(:x) { 4 }
　　　　　　　let(:y) { 5 }
            it_behaves_like 'Processus 1 et processus 3 passes'
          end
        end
        context 'x<y et x sont pairs et x*y<10' do
          context 'Passez par le processus 1 et le processus 4' do
            let(:x) { 2 }
            let(:y) { 3 }
            it_behaves_like 'Processus 1 et processus 4 passes'
          end
        end
        context 'x<y et x sont impairs et x*y>10' do
          context 'Passez par le processus 2 et le processus 3' do
            let(:x) { 3 }
            let(:y) { 5 }
            it_behaves_like 'Processus 2 et processus 3 passes'
          end
        end
        context 'x<y et x sont impairs et x*y<10' do
          context 'Passez par le processus 2 et le processus 4' do
            let(:x) { 1 }
            let(:y) { 4 }
            it_behaves_like 'Processus 2 et processus 4 passes'
          end
        end
      end
    end
  end
end

C'est facile à comprendre si vous l'écrivez comme ça. La couverture du code est appropriée, mais au travail, elle dépend de C1.