web-dev-qa-db-fra.com

Différences entre les données indiquées alors (GWT) et organiser la loi Aster (AAA)?

Dans TDD, il existe une syntaxe AAA ACTERGE ACTER (AAA):

[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);
}

Dans BDD, les tests d'écriture utilisent une structure similaire mais avec la syntaxe (GWT):

    [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 */   }

Bien qu'ils soient souvent considérés comme les mêmes, il y a des différences. Quelques clés sont:

  1. GWT peut être cartographié directement à la spécification d'un fichier de fonctionnalités dans les cadres BDD

  2. GWT est plus facile pour les non-développeurs à comprendre en encourageant l'utilisation de l'anglais ordinaire et d'avoir une brève description de ce que chaque partie fait

  3. Indiqué quand, puis sont des mots-clés dans diverses frayères BDD telles que SPECFLOW, et concombre

Ma question est là d'autres différences (en plus des noms) entre AAA et GWT? Et existe-t-il une raison en dehors de ceux spécifiés ci-dessus que l'on devrait être préféré sur l'autre?

c#unit-testingtddbdd
13
Cognitive_chaos

Je pense que vous avez énuméré très bien les différences dans votre question, mais j'ajouterai mes opinions sur la manière dont je vis les deux approches.

AAA est très utile pour moi lorsque je teste mon propre code. Si je travaille sur un projet ou une bibliothèque pour moi-même, AAA est la façon dont je vais. Cela me permet de configurer tout ce que j'ai besoin d'exécuter mon test puis juste le tester . Il est rapide à configurer et rapide à vérifier que mon code fonctionne comme je m'attends.

GWT est utile dans les environnements commerciaux, où le travail effectué par les programmeurs doit être mappé à la valeur des entreprises. La valeur commerciale est mappée par des fonctionnalités et des caractéristiques espérons que cela ne présente pas de bugs. Il existe de nombreuses stratégies pour la cartographie des fonctionnalités pour la programmation des tâches, mais l'une d'entre elles consiste à répondre à des exigences. D'après mon expérience, les exigences varient des exigences au niveau de l'utilisateur jusqu'à la réalisation de petites tâches pour que l'utilisateur soit exécuté. Ceci est utile car il est facile pour les dirigeants de comprendre comment le travail effectué par le programmeur a un impact sur leurs clients/utilisateurs, et donc pourquoi les programmeurs ajoutent de la valeur à leur entreprise

  • Exigence au niveau de l'utilisateur: étant donné l'entrepôt comporte au moins N article (s) de l'inventaire, lorsqu'un utilisateur achète n article (s), puis les entrepôt navires n article (s) à l'utilisateur
  • EXIGENCE NIVEAU SYSTÈME 1: Compte tenu du système d'inventaire de N article (s) d'inventaire, lorsqu'une demande de n article (s) est entré dans le système d'inventaire, le système d'inventaire diminue le nombre d'inventaire pour ce type d'élément.
  • Niveau de système 2: Compte tenu du système de paiement Note (s) de l'inventaire, lorsqu'une demande de n article (s) est entrée dans le système de paiement, le système de paiement facture l'utilisateur pour N article (s)
  • ...
  • Exigence au niveau du programmeur 1: 5 chandails sont en inventaire, lorsque 3 chandails sont retirés de l'inventaire, 2 places sont laissées dans l'inventaire.
  • ...

Ce type de structure d'exigence permet de concevoir une arborescence dans laquelle toutes les exigences de niveau de programmeur ont une carte dans l'arborescence aux exigences au niveau de l'utilisateur. De cette manière, lorsqu'un exigence de niveau de programmeur échoue, vous savez quelle condition de niveau utilisateur est affectée.

En revanche, un test AAA pourrait ressembler à ceci. Cela pour moi est très programmé face et pas utile à l'entreprise. Cela ne veut pas dire une structure d'arbre similaire d'exigences ne pouvait être faite à partir d'une stratégie de test AAA, mais rien dans la langue de l'AAA ne facilite la tâche.

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

Je suppose que cela dépend du cadre que vous utilisez. Généralement, jusqu'à ma compréhension, AAA est soutenu par le cadre de la Nunit et est donc le choix naturel à cet égard. Quant aux différences théoriques entre TDD et BDD, ils semblent être légers. Voir - this lien, quelqu'un de plus qualifié que moi pour vous donner une explication.

4
George Grainger

Il n'y a pas de différence du tout.
[.____] Trois états de test:
[.____] donné = organiser,
[.____] quand = acte,
[.____] alors = affirmer.

Les différences que vous avez fournies dans la question sont des différences entre TDD et BDD et non GWT et AAA.

Dans TDD, vous pouvez avoir trois méthodes différentes pour un test

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