Sollte ich Unit-Tests auf bekannte Mängel durchführen lassen?

Wenn mein Code einen bekannten Fehler enthält, der behoben werden sollte, aber noch nicht vorliegt und für die aktuelle Version nicht behoben wird und möglicherweise in absehbarer Zukunft nicht behoben wird, sollte ein fehlgeschlagener Komponententest für diesen Fehler vorliegen die Testsuite? Wenn ich den Komponententest hinzufüge, wird er (offensichtlich) fehlschlagen, und es scheint eine schlechte Idee zu sein, sich daran zu gewöhnen, dass Tests fehlschlagen. Wenn es sich andererseits um einen bekannten Defekt handelt und ein bekanntermaßen fehlerhafter Fall vorliegt, erscheint es seltsam, ihn aus der Testsuite herauszuhalten, da er irgendwann behoben werden sollte und der Test bereits verfügbar ist.

Die Antwort lautet: Ja, Sie sollten sie schreiben und ausführen.

Ihr Test-Framework benötigt eine Kategorie von "bekannten fehlgeschlagenen Tests" und Sie sollten diese Tests als in diese Kategorie fallend markieren. Wie Sie das machen, hängt vom Framework ab.

Seltsamerweise kann ein nicht bestandener Test genauso interessant sein wie ein nicht bestandener Test, der unerwartet fehlschlägt.

Ich denke, Sie sollten einen Komponententest mit dem aktuellen Verhalten durchführen und in den Kommentaren den richtigen Test und das richtige Verhalten hinzufügen. Beispiel:

@Test
public void test() {
  // this is wrong, it should be fixed some time
  Assert.assertEquals(2, new Calculator().plus(2,2));
  // this is the expected behaviour, replace the above test when the fix is available
  // Assert.assertEquals(4, new Calculator().plus(2, 2));
}

Auf diese Weise schlägt der Build fehl, sobald der Fix verfügbar ist, und Sie werden auf den fehlgeschlagenen Test hingewiesen. Wenn Sie sich den Test ansehen, werden Sie feststellen, dass Sie das Verhalten geändert haben und der Test aktualisiert werden muss.

EDIT: Wie Captain Man sagte, wird dies in großen Projekten nicht so schnell behoben, aber aus Dokumentationsgründen ist die ursprüngliche Antwort besser als nichts.

Eine bessere Möglichkeit besteht darin, den aktuellen Test zu duplizieren und dafür zu sorgen, dass der Klon das Richtige behauptet und @Ignoredies mit einer Meldung, z

@Test
public void test() {
  Assert.assertEquals(2, new Calculator().plus(2,2));
}

@Ignore("fix me, Calculator is giving the wrong result, see ticket BUG-12345 and delete #test() when fixed")
@Test
public void fixMe() {
  Assert.assertEquals(4, new Calculator().plus(2, 2));
}

Dies ist mit der Konvention in Ihrem Team verbunden, um die Anzahl der @IgnoreD-Tests zu reduzieren . Genauso wie Sie den Test einführen oder ändern würden, um den Fehler wiederzugeben, mit der Ausnahme, dass Sie den Build nicht fehlschlagen, wenn dies für Ihr Team kritisch ist, wie OP sagte, dass der Bugfix nicht in der aktuellen Version enthalten sein wird .

Je nach Testwerkzeug können Sie eine omitoder pend-Funktion verwenden.

Beispiel in Rubin:

gem 'test-unit', '>= 2.1.1'
require 'test/unit'

MYVERSION = '0.9.0' #Version of the class you test 


class Test_omit < Test::Unit::TestCase
  def test_omit
    omit('The following assertion fails - it will be corrected in the next release')
    assert_equal(1,2)
  end

  def test_omit_if
    omit_if(MYVERSION < '1.0.0', "Test skipped for version #{MYVERSION}")
    assert_equal(1,2)
  end

end

Der omitBefehl überspringt einen Test und omit_ifkombiniert ihn mit einem Test. In meinem Beispiel teste ich die Versionsnummer und führe den Test nur für Versionen aus, bei denen ich davon ausgehe, dass der Fehler behoben ist.

Die Ausgabe meines Beispiels ist:

Loaded suite test
Started
O
===============================================================================
The following assertion fails - it will be corrected in the next release [test_omit(Test_omit)]
test.rb:10:in `test_omit'
===============================================================================
O
===============================================================================
Test skipped for version 0.9.0 [test_omit_if(Test_omit)]
test.rb:15:in `test_omit_if'
===============================================================================


Finished in 0.0 seconds.

2 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, 2 omissions, 0 notifications
0% passed

Also meine Antwort: Ja, implementiere den Test. Aber verwechseln Sie einen Tester nicht mit Fehlern, von denen Sie wissen, dass sie fehlschlagen werden.

Wenn der Fehler in Ihrem Kopf frisch ist und Sie die Zeit haben, den Komponententest jetzt zu schreiben, würde ich ihn jetzt schreiben und als bekannten Fehler kennzeichnen, damit der Build selbst nicht fehlschlägt. Ihr Bug-Tracker sollte aktualisiert werden, um darauf hinzuweisen, dass derzeit ein Komponententest für diesen Bug fehlschlägt, damit die Person, die ihn schließlich beheben soll, ihn nicht erneut schreibt. Dies setzt voraus, dass der Buggy-Code nicht viel überarbeitet werden muss und dass sich die API erheblich ändert. Wenn dies der Fall ist, ist es möglicherweise besser, den Komponententest erst dann zu schreiben, wenn Sie eine bessere Vorstellung davon haben, wie der Test geschrieben werden sollte .

Die Antwort ist IMHO NEIN. Sie sollten erst dann einen Komponententest für den Fehler hinzufügen, wenn Sie mit der Behebung des Fehlers beginnen und dann die Tests schreiben, die den Fehler beweisen, und wenn dieser Test gemäß dem Fehlerbericht fehlschlägt ( s) Sie werden den tatsächlichen Code korrigieren, um den Test (die Tests) zu bestehen, und der Fehler wird behoben, und danach wird er behandelt.

In meiner Welt hätten wir einen manuellen Testfall, bei dem die QEs fehlschlagen, bis der Fehler behoben ist. Und uns als Entwickler wäre dies über die manuelle Fehleranalyse und den Bug-Tracker bekannt.

Der Grund, fehlgeschlagene UTs nicht hinzuzufügen, ist einfach. UTs dienen der direkten Rückmeldung und Validierung dessen, was ich als Entwickler gerade arbeite. Und UTs werden im CI-System verwendet, um sicherzustellen, dass ich in keinem anderen Codebereich für dieses Modul ungewollt etwas kaputtgemacht habe. Es wäre kontraproduktiv und einfach falsch, wenn UTs absichtlich wegen eines bekannten Fehlers ausfallen würden.

Ich nehme an, die Antwort ist wirklich, es kommt darauf an. Sei pragmatisch. Was bringt dir das Schreiben jetzt? Vielleicht ist es frisch in deinem Kopf?

Wenn Sie den Fehler beheben, ist es absolut sinnvoll, seine Existenz zu beweisen, indem Sie einen Komponententest schreiben, der den Fehler aufdeckt. Sie beheben dann den Fehler und der Komponententest sollte bestanden werden.

Haben Sie gerade Zeit, den fehlerhaften Komponententest zu schreiben? Gibt es dringendere Funktionen oder Fehler, die geschrieben / behoben werden müssen?

Vorausgesetzt, Sie haben eine kompetente Bug-Tracking-Software, in der der Bug angemeldet ist, müssen Sie den fehlgeschlagenen Unit-Test jetzt nicht schreiben .

Möglicherweise können Sie Verwirrung stiften, wenn Sie einen fehlgeschlagenen Komponententest vor einer Version einführen, die ohne die Fehlerbehebung ausgeführt wird.

Normalerweise ist es mir unangenehm, bekannte Fehler in Testsuiten zu haben, weil es zu einfach ist, die Liste im Laufe der Zeit zu erweitern oder nicht verwandte Fehler in denselben Tests als "erwartet" abzulehnen. Das Gleiche gilt für zeitweise auftretende Fehler - möglicherweise lauert etwas Böses im Code. Ich würde dafür stimmen, den Test für den Code so zu schreiben, wie er jetzt ist und wie er sein sollte, sobald er repariert, aber auskommentiert oder irgendwie deaktiviert ist.