it-swarm.com.de

Unterschiede zwischen Given When Then (GWT) und Arrange Act Assert (AAA)?

In TDD gibt es die AAA-Syntax (Arrange Act Assert):

[Test]
public void Test_ReturnItemForRefund_ReturnsStockOfBlackSweatersAsTwo_WhenOneInStockAndOneIsReturned()
{
    //Arrange
    ShopStock shopStock = new ShopStock();
    Item blackSweater = new Item("ID: 25");
    shopStock.AddStock(blackSweater);
    int expectedResult = 2;
    Item blackSweaterToReturn = new Item("ID: 25");

    //Act
    shopStock.ReturnItemForRefund(blackSweaterToReturn);
    int actualResult = shopStock.GetStock("ID: 25");

    //Assert
    Assert.AreEqual(expectedResult, actualResult);
}

In BDD-Schreibtests wird eine ähnliche Struktur verwendet, jedoch mit der GWT-Syntax (Given When Then):

    [Given(@"a customer previously bought a black sweater from me")]
    public void GivenACustomerPreviouslyBoughtABlackSweaterFromMe()
    { /* Code goes here */   }

    [Given(@"I currently have three black sweaters left in stock")]
    public void GivenICurrentlyHaveThreeBlackSweatersLeftInStock()
    { /* Code goes here */   }

    [When(@"he returns the sweater for a refund")]
    public void WhenHeReturnsTheSweaterForARefund()
    { /* Code goes here */   }

    [Then(@"I should have four black sweaters in stock")]
    public void ThenIShouldHaveFourBlackSweatersInStock()
    { /* Code goes here */   }

Obwohl sie oft als gleich angesehen werden, gibt es Unterschiede. Einige wichtige sind:

  1. GWT kann direkt der Spezifikation einer Feature-Datei in BDD-Frameworks zugeordnet werden

  2. GWT ist für Nicht-Entwickler leichter zu verstehen, da die Verwendung von einfachem Englisch gefördert wird und eine kurze Beschreibung der einzelnen Teile gegeben wird

  3. Gegeben, wann und wann sind Schlüsselwörter in verschiedenen BDD-Frameworks wie SpecFlow und Cucumber

Meine Frage ist, gibt es noch andere Unterschiede (neben den Namen) zwischen AAA und GWT? Und gibt es außer den oben genannten noch einen Grund, warum einer dem anderen vorgezogen werden sollte?

13
Cognitive_chaos

Ich denke, Sie haben die Unterschiede in Ihrer Frage sehr gut aufgelistet, aber ich werde einige meiner Meinungen dazu hinzufügen, wie ich die beiden Ansätze betrachte.

AAA ist sehr nützlich für mich, wenn ich meinen eigenen Code teste. Wenn ich selbst an einem Projekt oder einer Bibliothek arbeite, gehe ich AAA. Damit kann ich alles einrichten, was ich zum Ausführen meines Tests benötige, und es dann einfach testen . Es ist schnell einzurichten und schnell zu überprüfen, ob mein Code wie erwartet funktioniert.

GWT ist in Geschäftsumgebungen nützlich, in denen die von Programmierern geleistete Arbeit dem Geschäftswert zugeordnet werden muss. Der Geschäftswert wird durch Funktionen und hoffentlich durch Funktionen abgebildet, die keine Fehler verursachen. Es gibt viele Strategien, um Funktionen Programmieraufgaben zuzuordnen, aber eine davon sind Anforderungen. Nach meiner Erfahrung reichen die Anforderungen von Anforderungen auf Benutzerebene bis hin zu kleinen Aufgaben, die der Benutzer ausführen muss. Dies ist nützlich, weil es ist für die Manager leicht zu verstehen, wie sich die Arbeit des Programmierers auf ihre Kunden/Benutzer auswirkt und warum die Programmierer einen Mehrwert für ihr Geschäft schaffen

  • Anforderung auf Benutzerebene: Wenn das Lager mindestens N Artikel im Inventar hat und ein Benutzer N Artikel kauft, sendet das Lager N Artikel an den Benutzer
  • Anforderung 1 auf Systemebene: Wenn das Inventarsystem N Artikel im Inventar hat, verringert das Inventarsystem die Inventaranzahl für diesen Artikeltyp, wenn eine Anforderung für N Artikel in das Inventarsystem eingegeben wird
  • Anforderung 2 auf Systemebene: Wenn das Zahlungssystem N Artikel im Inventar hat, berechnet das Zahlungssystem dem Benutzer N Artikel, wenn eine Anforderung für N Artikel in das Zahlungssystem eingegeben wird.
  • ...
  • Anforderung 1 auf Programmiererebene: Wenn 5 Pullover im Inventar sind, bleiben 2 Sitzer im Inventar, wenn 3 Pullover aus dem Inventar entfernt werden
  • ...

Diese Art von Anforderungsstruktur ermöglicht ein baumartiges Design, bei dem alle Anforderungen auf Programmiererebene den Baum den Anforderungen auf Benutzerebene zuordnen. Auf diese Weise wissen Sie, wenn eine Anforderung auf Programmiererebene fehlschlägt, welche Anforderung auf Benutzerebene betroffen ist.

Im Gegensatz dazu könnte ein AAA-Test so aussehen. Dies ist für mich sehr programmiererisch und für das Geschäft nicht nützlich. Das heißt nicht, dass eine ähnliche Baumstruktur von Anforderungen nicht aus einer AAA-Teststrategie erstellt werden könnte, aber nichts in der Sprache von AAA macht dies einfacher.

public void Test_CaseWhereThereAreEnoughSweatersLeft() {
    // Arrange
    // setup Sweater Inventory mock (DB mocks, etc)
    // count = 5
    // when The number of sweaters remaining is request, return count
    // when Inventory is requested to remove N items, then count = count - N

    // Act
    // call the Unit Under Test to remove 3 items from inventory

    // Assert
    // the number of sweaters in the inventory is 2
    // the removal should return indicating a successful removal of items from the inventory
}

public void Test_CaseWhereThereAreNotEnoughSweatersLeft() {
    // Arrange
    // setup Sweater Inventory mock (DB mocks, etc)
    // count = 2
    // when The number of sweaters remaining is request, return count
    // when Inventory is requested to remove N items, then count = count - N

    // Act
    // call the Unit Under Test to remove 3 items from inventory

    // Assert
    // the number of sweaters remaining is still 2
    // the removal should return an error indicating not enough items in the inventory
}
9
Frank Bryce

Ich denke, es hängt von dem Framework ab, das Sie verwenden. Nach meinem Verständnis wird AAA im Allgemeinen vom NUnit-Framework unterstützt und ist daher in dieser Hinsicht die natürliche Wahl. Die theoretischen Unterschiede zwischen TDD und BDD scheinen gering zu sein. Siehe this Link, jemand, der qualifizierter ist als ich, um Ihnen eine Erklärung zu geben.

4
George Grainger

Es gibt überhaupt keinen Unterschied.
Drei Testzustände:
Gegeben = Anordnen,
Wenn = Akt,
Dann = Assert.

Unterschiede, die Sie in der Frage angegeben haben, sind Unterschiede zwischen TDD und BDD und nicht zwischen GWT und AAA.

In TDD können Sie drei verschiedene Methoden für einen Test verwenden

public class TestsOfFormatMethod
{        
    public void Arrange() { // set dependencies }
    public string Act() { // return formattted result }
    public string AssertThatFormatIsEmpty()
    {
        Arrange();
        var actual = Act();
        Assert.IsEmpty(actual);
    }
}
2
Fabio