Best Practices für die Benennung von Komponententests [geschlossen]

Was sind die Best Practices für die Benennung von Unit-Testklassen und Testmethoden?

Dies wurde bereits in SO unter Was sind einige beliebte Namenskonventionen für Unit-Tests?

Ich weiß nicht, ob dies ein sehr guter Ansatz ist, aber derzeit habe ich in meinen Testprojekten Eins-zu-Eins-Zuordnungen zwischen jeder Produktionsklasse und einer Testklasse, z . B. Productund ProductTest.

In meinen Testklassen habe ich dann Methoden mit den Namen der Methoden, die ich teste, einen Unterstrich und dann die Situation und was ich erwarte, z Save_ShouldThrowExceptionWithNullName().

Ich mag Roy Osheroves Namensstrategie , es ist die folgende:

[UnitOfWork_StateUnderTest_ExpectedBehavior]

Es enthält alle Informationen zum Methodennamen und ist strukturiert.

Die Arbeitseinheit kann so klein wie eine einzelne Methode, eine Klasse oder so groß wie mehrere Klassen sein. Es sollte alle Dinge darstellen, die in diesem Testfall getestet werden sollen und unter Kontrolle sind.

Für Assemblys verwende ich die typische .TestsEndung, die meiner Meinung nach ziemlich weit verbreitet ist, und dieselbe für Klassen (Endung mit Tests):

[NameOfTheClassUnderTestTests]

Früher habe ich Fixture als Suffix anstelle von Tests verwendet, aber ich denke, letzteres ist häufiger, dann habe ich die Namensstrategie geändert.

Ich befolge gerne den Namensstandard "Sollte" für Tests, während ich das Testgerät nach dem zu testenden Gerät (dh der Klasse) benenne.

Zur Veranschaulichung (mit C # und NUnit):

[TestFixture]
public class BankAccountTests
{
  [Test]
  public void Should_Increase_Balance_When_Deposit_Is_Made()
  {
     var bankAccount = new BankAccount();
     bankAccount.Deposit(100);
     Assert.That(bankAccount.Balance, Is.EqualTo(100));
  }
}

Warum "sollte" ?

Ich finde, dass es die Testschreiber zwingt, den Test mit einem Satz zu benennen, der so lautet: "Sollte [in einem Zustand sein] [nach / vor / wann] [Aktion findet statt]".

Ja, das Schreiben von "Sollte" überall wiederholt sich ein wenig, aber wie gesagt, es zwingt die Autoren, richtig zu denken (kann also gut für Anfänger sein). Außerdem führt dies im Allgemeinen zu einem lesbaren englischen Testnamen.

Update :

Mir ist aufgefallen, dass Jimmy Bogard auch ein Fan von "sollte" ist und sogar eine Unit-Test-Bibliothek namens hat Sollte" hat .

Update (4 Jahre später ...)

Für Interessierte hat sich mein Ansatz zur Benennung von Tests im Laufe der Jahre weiterentwickelt. Eines der Probleme mit dem oben beschriebenen Sollte- Muster ist nicht einfach auf einen Blick zu erkennen, welche Methode getestet wird. Für OOP halte ich es für sinnvoller, den Testnamen mit der zu testenden Methode zu beginnen. Für eine gut gestaltete Klasse sollte dies zu lesbaren Testmethodennamen führen. Ich benutze jetzt ein ähnliches Format wie <method>_Should<expected>_When<condition>. Je nach Kontext möchten Sie natürlich die Sollte / Wann-Verben durch etwas Passenderes ersetzen. Beispiel: Deposit_ShouldIncreaseBalance_WhenGivenPositiveValue()

Ich mag diesen Namensstil:

OrdersShouldBeCreated();
OrdersWithNoProductsShouldFail();

und so weiter. Es macht einem Nicht-Tester wirklich klar, wo das Problem liegt.

Kent Beck schlägt vor:

• Ein Testgerät pro 'Einheit' (Klasse Ihres Programms). Prüfvorrichtungen sind Klassen selbst. Der Name des Testgeräts sollte lauten:

  [name of your 'unit']Tests
  

• Testfälle (die Testvorrichtungsmethoden) haben folgende Namen:

  test[feature being tested]
  

Zum Beispiel mit der folgenden Klasse:

class Person {
    int calculateAge() { ... }

    // other methods and properties
}

Ein Testgerät wäre:

class PersonTests {

    testAgeCalculationWithNoBirthDate() { ... }

    // or

    testCalculateAge() { ... }
}

Klassennamen . Bei Namen von Testgeräten finde ich, dass "Test" in der allgegenwärtigen Sprache vieler Domänen weit verbreitet ist. Zum Beispiel in einem technischen Bereich: StressTestund in einem kosmetischen Bereich : SkinTest. Es tut mir leid, Kent nicht zuzustimmen, aber die Verwendung von "Test" in meinen Testgeräten ( StressTestTest?) Ist verwirrend.

"Einheit" wird auch häufig in Domänen verwendet. ZB MeasurementUnit. Wird eine Klasse als MeasurementUnitTestTest von "Measurement" oder "MeasurementUnit" bezeichnet?

Daher verwende ich gerne das Präfix "Qa" für alle meine Testklassen. ZB QaSkinTestund QaMeasurementUnit. Es wird nie mit Domänenobjekten verwechselt, und die Verwendung eines Präfixes anstelle eines Suffix bedeutet, dass alle Testgeräte visuell zusammenleben (nützlich, wenn Sie Fälschungen oder andere Unterstützungsklassen in Ihrem Testprojekt haben).

Namespaces . Ich arbeite in C # und behalte meine Testklassen im selben Namespace wie die Klasse, die sie testen. Dies ist bequemer als separate Test-Namespaces. Natürlich befinden sich die Testklassen in einem anderen Projekt.

Namen der Testmethoden . Ich möchte meine Methoden WhenXXX_ExpectYYY nennen. Es macht die Voraussetzung klar und hilft bei der automatisierten Dokumentation (a la TestDox). Dies ähnelt den Ratschlägen im Google-Testblog, jedoch mit einer stärkeren Trennung von Voraussetzungen und Erwartungen. Zum Beispiel:

WhenDivisorIsNonZero_ExpectDivisionResult
WhenDivisorIsZero_ExpectError
WhenInventoryIsBelowOrderQty_ExpectBackOrder
WhenInventoryIsAboveOrderQty_ExpectReducedInventory

Ich verwende das Given-When-Then- Konzept. Schauen Sie sich diesen kurzen Artikel an: http://cakebaker.42dh.com/2009/05/28/given-when-then/ . Artikel beschreibt dieses Konzept in Bezug auf BDD, aber Sie können es auch in TDD ohne Änderungen verwenden.

Siehe: http://googletesting.blogspot.com/2007/02/tott-naming-unit-tests-responsibly.html

Für Namen von Testmethoden finde ich es persönlich sehr nützlich, ausführliche und selbstdokumentierte Namen zu verwenden (neben Javadoc-Kommentaren, die näher erläutern, was der Test tut).

Ich denke, eines der wichtigsten Dinge ist, dass Sie in Ihrer Namenskonvention konsistent sind (und dies mit anderen Mitgliedern Ihres Teams vereinbaren). Zu oft sehe ich viele verschiedene Konventionen, die im selben Projekt verwendet werden.

Ich habe kürzlich die folgende Konvention entwickelt, um meine Tests, ihre Klassen und Projekte zu benennen, um ihre Beschreibungen zu maximieren:

Nehmen wir an, ich teste die SettingsKlasse in einem Projekt im MyApp.SerializationNamespace.

Zuerst werde ich ein Testprojekt mit dem MyApp.Serialization.TestsNamespace erstellen .

Innerhalb dieses Projekts und natürlich des Namespace werde ich eine Klasse namens IfSettings(gespeichert als IfSettings.cs ) erstellen .

Nehmen wir an, ich teste die SaveStrings()Methode. -> Ich werde den Test benennen CanSaveStrings().

Wenn ich diesen Test durchführe, wird die folgende Überschrift angezeigt:

MyApp.Serialization.Tests.IfSettings.CanSaveStrings

Ich denke, das sagt mir sehr gut, was es testet.

Natürlich ist es nützlich, dass das Substantiv "Tests" im Englischen dasselbe ist wie das Verb "tests".

Ihrer Kreativität bei der Benennung der Tests sind keine Grenzen gesetzt, sodass wir vollständige Satzüberschriften für sie erhalten.

Normalerweise müssen die Testnamen mit einem Verb beginnen.

Beispiele beinhalten:

• Erkennt (zB DetectsInvalidUserInput)
• Würfe (zB ThrowsOnNotFound)
• Will (zB WillCloseTheDatabaseAfterTheTransaction)

usw.

Eine andere Möglichkeit ist, "das" anstelle von "wenn" zu verwenden.

Letzteres erspart mir jedoch Tastatureingaben und beschreibt genauer, was ich tue, da ich nicht weiß, dass das getestete Verhalten vorhanden ist, aber teste, ob es vorhanden ist.

[ Bearbeiten ]

Nachdem ich die obige Namenskonvention nun etwas länger verwendet habe, habe ich festgestellt, dass das If- Präfix bei der Arbeit mit Schnittstellen verwirrend sein kann. Es ist einfach so, dass die Testklasse IfSerializer.cs der Schnittstelle ISerializer.cs auf der Registerkarte "Dateien öffnen " sehr ähnlich sieht . Dies kann sehr ärgerlich werden, wenn zwischen den Tests, der getesteten Klasse und ihrer Schnittstelle hin und her gewechselt wird. Als Ergebnis würde ich jetzt That anstelle von If als Präfix wählen .

Zusätzlich verwende ich jetzt - nur für Methoden in meinen Testklassen, da dies nirgendwo anders als Best Practice angesehen wird - das "_", um Wörter in meinen Testmethodennamen wie folgt zu trennen:

[Test] public void detects_invalid_User_Input()

Ich finde das leichter zu lesen.

[ Bearbeiten beenden ]

Ich hoffe, dass dies weitere Ideen hervorbringt, da ich die Benennung von Tests für sehr wichtig halte, da Sie dadurch viel Zeit sparen können, die sonst aufgewendet worden wäre, um zu verstehen, was die Tests tun (z. B. nach Wiederaufnahme eines Projekts nach einer längeren Pause). .

In VS + NUnit erstelle ich normalerweise Ordner in meinem Projekt, um Funktionstests zu gruppieren. Dann erstelle ich Unit-Test-Fixture-Klassen und benenne sie nach der Art der Funktionalität, die ich teste. Die [Test] -Methoden sind wie folgt benannt Can_add_user_to_domain:

- MyUnitTestProject   
  + FTPServerTests <- Folder
   + UserManagerTests <- Test Fixture Class
     - Can_add_user_to_domain  <- Test methods
     - Can_delete_user_from_domain
     - Can_reset_password

Ich sollte hinzufügen, dass das Speichern Ihrer Tests im selben Paket, aber in einem parallelen Verzeichnis zur getesteten Quelle, das Aufblähen des Codes beseitigt, sobald Sie bereit sind, ihn bereitzustellen, ohne eine Reihe von Ausschlussmustern ausführen zu müssen.

Ich persönlich mag die in "JUnit Pocket Guide" beschriebenen Best Practices ... es ist schwer, ein Buch zu schlagen, das vom Co-Autor von JUnit geschrieben wurde!

Der Name des Testfalls für die Klasse Foo sollte FooTestCase oder ähnliches sein (FooIntegrationTestCase oder FooAcceptanceTestCase) - da es sich um einen Testfall handelt. Unter http://xunitpatterns.com/ finden Sie einige Standard-Namenskonventionen wie Test, Testfall, Testvorrichtung, Testmethode usw.