Frage

Manchmal komme ich einen Komponententest accross, die nichts geltend macht. Das spezielle Beispiel, das ich über diesen Morgen kam testet, dass eine Protokolldatei geschrieben wurde, wenn eine Bedingung erfüllt wurde. Die Annahme war, dass, wenn kein Fehler der Test bestanden geworfen wurde.

Ich persönlich habe kein Problem damit haben, aber es ist ein bisschen wie ein „Codegeruch“ zu sein scheint eine Einheit Test zu schreiben, die keine Aussagen mit ihm verbunden.

Nur frage mich, was die Ansichten der Menschen auf diesem sind?

War es hilfreich?

Lösung

Dies wäre der offiziellen Weg, es zu tun:

// Act
Exception ex = Record.Exception(() => someCode());

// Assert
Assert.Null(ex);

Andere Tipps

Es ist einfach ein sehr minimal-Test, und soll als solche zu dokumentieren. Es prüft nur, dass es nicht explodiert, wenn laufen. Der schlimmste Teil über Tests wie dieser ist, dass sie ein falsches Gefühl der Sicherheit vorlegen. Ihre Code-Coverage wird steigen, aber es ist illusorisch. Sehr schlechter Geruch.

Wenn es keine Behauptung, es ist kein Test.

Beenden faul -. Es kann ein wenig Zeit nehmen, um herauszufinden, wie die Behauptung erhalten dort, aber es lohnt sich zu wissen, dass es tat, was Sie erwartet, zu tun

Diese werden als Rauchversuche bekannt und sind weit verbreitet. Sie sind grundlegende Plausibilitätsprüfungen. Aber sie sollten nicht die einzigen Arten von Tests, die Sie haben. Sie würden immer noch eine Art von Überprüfung in einem anderen Test benötigen.

Ein solcher Test riecht. Es sollte prüfen, ob die Datei geschrieben wurde, zumindest, dass die modifizierte Zeit vielleicht aktualisiert wurde.

Ich habe schon ein paar Tests auf diese Weise geschrieben gesehen, dass der Code bei allen das heißt nichts Prüfung am Ende funktionierte nicht, aber es hat auch nicht die Luft zu sprengen.

Wenn Sie einige explizite Anforderung haben, dass der im Test befindlichen Code keine Ausnahme werfen, und Sie mögen ausdrücklich auf diese Tatsache ausrufen (Tests als Anforderungen docs), dann würde ich so etwas tun:

try
{
  unitUnderTest.DoWork()
}
catch
{
  Assert.Fail("code should never throw exceptions but failed with ...")
}

... aber das riecht immer noch ein bisschen zu mir, wahrscheinlich, weil es einem negativen zu beweisen versucht.

In gewissem Sinne sind Sie machen eine implizite Behauptung - dass der Code keine Ausnahme werfen. Natürlich wäre es wertvoll sein, um die Datei tatsächlich greifen und die entsprechende Zeile finden, aber ich nehme etwas besser als nichts ist.

Generell sehe ich diese auftritt in Integrationstests, sondern nur die Tatsache, dass etwas gelungen, bis zum Abschluss gut genug ist. In diesem Fall Im kühlen damit.

Ich denke, wenn ich es über sah und immer wieder in Unit-Tests Ich wäre neugierig, wie nützlich die Tests wirklich waren.

EDIT: Im Beispiel durch die OP gegeben, gibt es einiges überprüfbares Ergebnis (Logfile Ergebnis), so davon aus, dass, wenn kein Fehler ausgelöst wurde, dass es funktioniert ist faul

.

Es kann eine gute pragmatische Lösung sein, vor allem, wenn die Alternative keinen Test überhaupt ist.

Das Problem ist, dass der Test passieren würde, wenn alle Funktionen no-ops genannt wurden. Aber manchmal ist es einfach nicht möglich, die Nebenwirkungen zu überprüfen sind, was Sie erwarten. In einer idealen Welt gäbe es genug Zeit, um die Kontrollen für jeden Test zu schreiben ... aber ich weiß nicht dort leben.

Der andere Ort, wo ich dieses Muster verwendet habe, ist es, einige Performance-Tests mit Unit-Tests für die Einbettung, weil das eine einfache Möglichkeit, war sie jeden Build laufen zu bekommen. Die Tests behaupten nicht alles, aber messen, wie lange der Test, dass nahm und protokollieren.

Ich habe so etwas wie dies gesehen und ich denke, das gerade getan wurde Code-Coverage-Zahlen zu stützen. Es ist wahrscheinlich nicht wirklich Code Verhalten zu testen. Auf jeden Fall, ich stimme, dass sie (die Absicht) sollten in einem Test Klarheit dokumentiert werden.

Der Name des Tests sollte dies dokumentiert werden.

void TestLogDoesNotThrowException(void) {
    log("blah blah");
}

Wie funktioniert der Test überprüfen, ob das Protokoll ohne Behauptung geschrieben?

Ich muss zugeben, dass ich noch nie einen Komponententest geschrieben, die überprüft ich die Anmeldung korrekt. Aber ich habe darüber nachdenkt und kam in dieser Diskussion , wie könnte es mit JUnit und Log4J erfolgen. Es ist nicht zu hübsch, aber es sieht aus wie es funktionieren würde.

Die Tests sollten immer etwas behaupten, sonst, was Sie beweisen, und wie können Sie konsequent reproduzieren Hinweise darauf, dass Ihr Code funktioniert?

Wir tun dies die ganze Zeit. Wir verspotten unsere Abhängigkeiten mit JMock, also denke ich, in einem gewissen Sinne die JMock Rahmen für uns die Behauptung tut ... aber es geht etwas ähnliches. Wir haben einen Controller, die wir testen wollen:

Class Controller {
  private Validator validator;

  public void control(){
    validator.validate;
  }

  public setValidator(Validator validator){ this.validator = validator; }
}

Wenn wir jetzt Regler testen wir nicht‘wollen Validator testen, da es seine eigene Tests hat. so haben wir einen Test mit JMock nur um sicherzustellen, dass wir nennen validate:

public void testControlShouldCallValidate(){
  mockValidator.expects(once()).method("validate");
  controller.control;
}

Und das ist alles, gibt es keine „Behauptung“ zu sehen, aber wenn Sie die Kontrolle nennen und die „Validate“ Methode wird nicht aufgerufen, dann wird der JMock Rahmen wirft eine Ausnahme (so etwas wie „erwartete Methode nicht aufgerufen“ oder so).

Wir haben alle über den Platz. Es ist ein wenig nach hinten, da man im Grunde Setup dann Behauptung den Anruf an die bewährten Methode machen.

Manchmal benutze ich meine Einheit Test-Framework der Wahl (NUnit) Methoden zu entwickeln, die als Einstiegspunkte in bestimmte Teile meines Codes handeln. Diese Verfahren eignen sich für die Profilierung Leistung, Speicherverbrauch und Ressourcenverbrauch einer Teilmenge des Codes.

Diese Methoden sind definitiv nicht Unit-Tests (auch wenn sie mit der markiert sind [Test] Attribut) und werden immer ignoriert werden markiert und explizit dokumentiert, wenn sie in die Quellcodeverwaltung eingecheckt sind.

ich auch gelegentlich diese Methoden als Einstiegspunkte für das Visual Studio-Debugger verwenden. Ich benutze ReSharper direkt in den Test zu treten und dann in den Code, ich möchte debuggen. Diese Methoden entweder nicht machen es so weit wie Quellcodeverwaltung, oder sie erwerben ihre ganz eigenen behauptet.

Meine „echten“ Unit-Tests werden während der normalen TDD Zyklen aufgebaut, und sie immer etwas behaupten, wenn auch nicht immer direkt - manchmal sind die Behauptungen Teil des Mockframework sind, und manchmal ähnliche Behauptungen in einem einzigen Refactoring Ich bin in der Lage Methode. Die Namen dieser Refactoring Methoden immer mit dem Präfix „Assert“ beginnen, um es mir zu machen offensichtlich.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top