Verstehen Sie die Codeabdeckung mit Rspec, dem Ruby on Rails-Testframework

Wenn ich einen Testfall schreibe, bekomme ich eine Geschichte darüber, wie viel Berichterstattung er abdeckt.

Was ist Codeabdeckung? Ich dachte, also werde ich es als mein Memorandum zusammenfassen.

Was ist Codeabdeckung?

Beim Softwaretest muss der gesamte Programmcode (interne Logik) getestet werden Es ist das Verhältnis (Abdeckungsrate) des getesteten Körperteils. Referenz

Typische Abdeckung

C0: Anweisungsabdeckung

Jede Anweisung wird mindestens einmal ausgeführt

C1: Zweigabdeckung

Für jede Beurteilungsbedingung mindestens einmal ausführen

C2: Zustandsdeckung

Die Authentizität in jeder bedingten Anweisung wird mindestens einmal ausgeführt

Kundencenter: Umfassende Zustandsabdeckung

Alle Kombinationen von Wahrheit und Falschheit, die in jede Bedingung gestellt werden können, werden ausgeführt

Schreiben Sie in der Tat Tests unter Berücksichtigung der Abdeckung mit Rspec

Ruby-Code zum Testen

sample.rb

module CodeCoverage
  class << self
  # main
  # @params [interger] x
  # @params [interger] y
  # @return [String]Zeichenfolgen, die sich je nach den Werten von x und y unterscheiden
  #
  #Das Argument geht nur von einer Interger aus
  def main(x, y)
    result = ''
    if x >= y || x % 2 == 0
      result << 'Prozess 1'
    else
      result << 'Prozess 2'
    end
    if x*y > 10
      result << 'Prozess 3'
    else
      result << 'Prozess 4'
    end
    return result
  end
  end
end

Testcode in Rspec geschrieben

Was ist Rspec

Eines der Frameworks zur Realisierung von TDD (Test Driven Development), einer der Entwicklungsmethoden von Ruby on Rails Referenz

Testcode Körper

RSpec.describe CodeCoverage do
  shared_examples 'Prozess 1 und Prozess 3 bestehen' do
    it 'Der Wortlaut von Prozess 1 und Prozess 3 wird zurückgegeben' do
      expect(subject).to eq 'Prozess 1 Prozess 3'
    end
  end
  shared_examples 'Prozess 1 und Prozess 4 bestehen' do
    it 'Der Wortlaut von Prozess 1 und Prozess 4 wird zurückgegeben' do
      expect(subject).to eq 'Prozess 1 Prozess 4'
    end
  end
  shared_examples 'Prozess 2 und Prozess 3 bestehen' do
    it 'Der Wortlaut von Prozess 2 und Prozess 3 wird zurückgegeben' do
      expect(subject).to eq 'Prozess 2 Prozess 3'
    end
  end
  shared_examples 'Prozess 2 und Prozess 4 bestehen' do
    it 'Der Wortlaut von Prozess 2 und Prozess 4 wird zurückgegeben' do
      expect(subject).to eq 'Prozess 2 Prozess 4'
    end
  end

  describe 'main' do
    subject { described_class.send(:main, x, y) }
      # C0:Anweisungsabdeckung
　　　 #Schreiben Sie, um mindestens einmal mit wenigen Anweisungen auszuführen
      context 'Für C0' do
        context 'Gehen Sie Prozess 1 und Prozess 3 durch' do
          let(:x) { 11 }
          let(:y) { 1 }
          it_behaves_like 'Prozess 1 und Prozess 3 bestehen'
        end
        context 'Gehen Sie Prozess 2 und Prozess 4 durch' do
          let(:x) { 1 }
          let(:y) { 9 }
          it_behaves_like 'Prozess 2 und Prozess 4 bestehen'
        end
      end
      # C1:Filialabdeckung
      #Für jede Beurteilungsbedingung mindestens einmal ausführen
      context 'Für C1' do
        context 'Gehen Sie Prozess 1 und Prozess 3 durch' do
          let(:x) { 11 }
          let(:y) { 1 }
          it_behaves_like 'Prozess 1 und Prozess 3 bestehen'
        end
        context 'Gehen Sie Prozess 1 und Prozess 4 durch' do
          let(:x) { 3 }
          let(:y) { 2 }
          it_behaves_like 'Prozess 1 und Prozess 4 bestehen'
        end
        context 'Gehen Sie Prozess 2 und Prozess 3 durch' do
          let(:x) { 3 }
          let(:y) { 5 }
          it_behaves_like 'Prozess 2 und Prozess 3 bestehen'
        end
        context 'Gehen Sie Prozess 2 und Prozess 4 durch' do
          let(:x) { 1 }
          let(:y) { 4 }
          it_behaves_like 'Prozess 2 und Prozess 4 bestehen'
        end
      end
      
      # C2:Zustandsdeckung
      #Die Authentizität in jeder bedingten Anweisung wird mindestens einmal ausgeführt
      context 'Für C2' do
        context 'x>=y und x*y>10' do
          context 'Gehen Sie Prozess 1 und Prozess 3 durch' do
            let(:x) { 11 }
            let(:y) { 1 }
            it_behaves_like 'Prozess 1 und Prozess 3 bestehen'
          end
        end
        context 'x>=y und x*y<10' do
          context 'Gehen Sie Prozess 1 und Prozess 4 durch' do
            let(:x) { 3 }
            let(:y) { 2 }
            it_behaves_like 'Prozess 1 und Prozess 4 bestehen'
          end
        end
        context 'x<y und x sind gerade und x*y>10' do
          context 'Gehen Sie Prozess 1 und Prozess 3 durch' do
            let(:x) { 4 }
　　　　　　　let(:y) { 5 }
            it_behaves_like 'Prozess 1 und Prozess 3 bestehen'
          end
        end
        context 'x<y und x sind gerade und x*y<10' do
          context 'Gehen Sie Prozess 1 und Prozess 4 durch' do
            let(:x) { 2 }
            let(:y) { 3 }
            it_behaves_like 'Prozess 1 und Prozess 4 bestehen'
          end
        end
        context 'x<y und x sind ungerade und x*y>10' do
          context 'Gehen Sie Prozess 2 und Prozess 3 durch' do
            let(:x) { 3 }
            let(:y) { 5 }
            it_behaves_like 'Prozess 2 und Prozess 3 bestehen'
          end
        end
        context 'x<y und x sind ungerade und x*y<10' do
          context 'Gehen Sie Prozess 2 und Prozess 4 durch' do
            let(:x) { 1 }
            let(:y) { 4 }
            it_behaves_like 'Prozess 2 und Prozess 4 bestehen'
          end
        end
      end
    end
  end
end

Es ist leicht zu verstehen, wenn Sie es so schreiben. Wie viel Codeabdeckung erreicht wird, ist angemessen, aber bei der Arbeit liegt es an C1.