Devrait-il être «Arranger-Assert-Act-Assert»?

En ce qui concerne le modèle de test classique de Arrange-Act-Assert , je me retrouve souvent à ajouter une contre-affirmation qui précède Act. De cette façon, je sais que l'assertion passagère est en fait le résultat de l'action.

Je pense que c'est analogue au rouge en rouge-vert-refactor, où ce n'est que si j'ai vu la barre rouge au cours de mes tests que je sais que la barre verte signifie que j'ai écrit du code qui fait une différence. Si j'écris un test de réussite, alors n'importe quel code le satisfera; de même, en ce qui concerne Arrange-Assert-Act-Assert, si ma première affirmation échoue, je sais que n'importe quelle loi aurait adopté la déclaration finale - de sorte qu'elle ne vérifiait en fait rien au sujet de la Loi.

Vos tests suivent-ils ce modèle? Pourquoi ou pourquoi pas?

Mise à jour Clarification: l'assertion initiale est essentiellement l'opposé de l'assertion finale. Ce n'est pas une affirmation qu'Arrange a fonctionné; c'est une affirmation que Act n'a pas encore fonctionné.

Ce n'est pas la chose la plus courante à faire, mais assez courante pour avoir son propre nom. Cette technique s'appelle l' assertion de garde . Vous pouvez en trouver une description détaillée à la page 490 dans l'excellent livre xUnit Test Patterns de Gerard Meszaros (fortement recommandé).

Normalement, je n'utilise pas ce modèle moi-même, car je trouve plus correct d'écrire un test spécifique qui valide toute condition préalable que je ressens le besoin de garantir. Un tel test devrait toujours échouer si la condition préalable échoue, et cela signifie que je n'en ai pas besoin intégré dans tous les autres tests. Cela donne une meilleure isolation des préoccupations, puisqu'un cas de test ne vérifie qu'une seule chose.

Il peut y avoir de nombreuses conditions préalables qui doivent être satisfaites pour un cas de test donné, vous pouvez donc avoir besoin de plusieurs assertions de garde. Au lieu de les répéter dans tous les tests, avoir un (et un seul) test pour chaque condition préalable permet de garder votre code de test plus durable, car vous aurez moins de répétition de cette façon.

Il peut également être spécifié comme Arrange- Assume -Act -Assert.

Il y a une poignée technique pour cela dans NUnit, comme dans l'exemple ici: http://nunit.org/index.php?p=theory&r=2.5.7

Voici un exemple.

public void testEncompass() throws Exception {
    Range range = new Range(0, 5);
    assertFalse(range.includes(7));
    range.encompass(7);
    assertTrue(range.includes(7));
}

Il se peut que j'écrive Range.includes()simplement pour retourner vrai. Je ne l'ai pas fait, mais je peux imaginer que je pourrais avoir. Ou j'aurais pu mal l'écrire de plusieurs autres manières. J'espérerais et je m'attendrais à ce qu'avec TDD, j'ai vraiment réussi - cela includes()fonctionne juste - mais peut-être que je ne l'ai pas fait. La première assertion est donc une vérification de bon sens, pour s'assurer que la seconde assertion est vraiment significative.

Lire par lui-même, assertTrue(range.includes(7));c'est dire: "affirmer que la plage modifiée comprend 7". Lire dans le contexte de la première assertion, il dit: "affirmer qu'invoquer encompass () le fait inclure 7. Et comme encompass est l'unité que nous testons, je pense que cela a une (petite) valeur.

J'accepte ma propre réponse; beaucoup d'autres ont mal interprété ma question comme étant de tester la configuration. Je pense que c'est légèrement différent.

Un Arrange-Assert-Act-Asserttest peut toujours être refactorisé en deux tests:

1. Arrange-Assert

et

2. Arrange-Act-Assert

Le premier test n'affirmera que sur ce qui a été mis en place dans la phase d'arrangement, et le second test ne s'appliquera que pour ce qui s'est passé dans la phase d'acte.

Cela a l'avantage de donner un retour plus précis sur si c'est la phase Arranger ou Act qui a échoué, alors que dans l'original, Arrange-Assert-Act-Assertelles sont confondues et vous devriez creuser plus profondément et examiner exactement quelle assertion a échoué et pourquoi elle a échoué afin de savoir si c'était l'arrangement ou la loi qui a échoué.

Il répond également mieux à l'intention des tests unitaires, car vous séparez votre test en unités indépendantes plus petites.

Enfin, gardez à l'esprit que chaque fois que vous voyez des sections d'arrangement similaires dans différents tests, vous devriez essayer de les extraire dans des méthodes d'aide partagées, afin que vos tests soient plus DRY. et plus maintenables à l'avenir.

Je fais maintenant cela. AAAA d'un type différent

Arrange - setup
Act - what is being tested
Assemble - what is optionally needed to perform the assert
Assert - the actual assertions

Exemple de test de mise à jour:

Arrange: 
    New object as NewObject
    Set properties of NewObject
    Save the NewObject
    Read the object as ReadObject

Act: 
    Change the ReadObject
    Save the ReadObject

Assemble: 
    Read the object as ReadUpdated

Assert: 
    Compare ReadUpdated with ReadObject properties

La raison en est que l'ACT ne contient pas la lecture de la ReadUpdated parce qu'elle ne fait pas partie de l'acte. L'acte ne fait que changer et sauver. Donc vraiment, ARRANGE ReadUpdated pour l'assertion, j'appelle ASSEMBLE pour l'assertion. Ceci afin d'éviter de confondre la section ARRANGE

ASSERT ne doit contenir que des assertions. Cela laisse ASSEMBLE entre ACT et ASSERT qui met en place l'assert.

Enfin, si vous échouez dans l'Arrangement, vos tests ne sont pas corrects car vous devriez avoir d'autres tests pour éviter / trouver ces bugs triviaux . Parce que pour le scénario que je présente, il devrait déjà y avoir d'autres tests qui testent READ et CREATE. Si vous créez une "Assertion de garde", vous risquez de rompre DRY et de créer une maintenance.

Lancer une assertion de «contrôle de cohérence» pour vérifier l'état avant d'effectuer l'action que vous testez est une vieille technique. Je les écris généralement comme des échafaudages de test pour me prouver que le test fait ce que j'attends, et je les supprime plus tard pour éviter d'encombrer les tests avec des échafaudages de test. Parfois, laisser l'échafaudage aide le test à servir de récit.

J'ai déjà lu cette technique - peut-être de votre part - mais je ne l'utilise pas; surtout parce que je suis habitué à la forme triple A pour mes tests unitaires.

Maintenant, je deviens curieux et j'ai quelques questions: comment rédigez-vous votre test, faites-vous échouer cette assertion, en suivant un cycle de refactorisation rouge-vert-rouge-vert, ou l'ajoutez-vous après?

Échouez-vous parfois, peut-être après avoir refactorisé le code? Qu'est-ce que cela vous dit? Peut-être pourriez-vous partager un exemple où cela a aidé. Merci.

J'ai déjà fait cela lors d'une enquête sur un test qui a échoué.

Après un grattage considérable de la tête, j'ai déterminé que la cause était que les méthodes appelées pendant «Arranger» ne fonctionnaient pas correctement. L'échec du test était trompeur. J'ai ajouté un Assert après l'arrangement. Cela a fait échouer le test dans un endroit qui a mis en évidence le problème réel.

Je pense qu'il y a aussi une odeur de code ici si la partie Arranger du test est trop longue et compliquée.

En général, j'aime beaucoup "Organiser, Agir, Affirmer" et l'utiliser comme norme personnelle. La seule chose qu'il ne me rappelle pas de faire, cependant, est de désorganiser ce que j'ai arrangé lorsque les affirmations sont faites. Dans la plupart des cas, cela ne cause pas beaucoup de gêne, car la plupart des choses disparaissent automatiquement via le garbage collection, etc. Si vous avez établi des connexions à des ressources externes, cependant, vous voudrez probablement fermer ces connexions lorsque vous avez terminé avec vos affirmations ou vous avez beaucoup un serveur ou une ressource coûteuse quelque part qui détient des connexions ou des ressources vitales qu'il devrait être en mesure de donner à quelqu'un d'autre. Ceci est particulièrement important si vous partie de ces développeurs qui n'utilisent pas TearDown ou TestFixtureTearDownà nettoyer après un ou plusieurs tests. Bien entendu, "Organiser, Agir, Assertir" n'est pas responsable de mon échec à fermer ce que j'ouvre; Je ne mentionne ce "gotcha" que parce que je n'ai pas encore trouvé de bon synonyme de "A-word" pour "disposer" à recommander! Aucune suggestion?

Jetez un œil à l'entrée de Wikipedia sur la conception par contrat . La sainte trinité Arrange-Act-Assert est une tentative d'encoder certains des mêmes concepts et vise à prouver l'exactitude du programme. De l'article:

The notion of a contract extends down to the method/procedure level; the
contract for each method will normally contain the following pieces of
information:

    Acceptable and unacceptable input values or types, and their meanings
    Return values or types, and their meanings
    Error and exception condition values or types that can occur, and their meanings
    Side effects
    Preconditions
    Postconditions
    Invariants
    (more rarely) Performance guarantees, e.g. for time or space used

Il y a un compromis entre la quantité d'efforts consacrés à la mise en place et la valeur ajoutée. AAA est un rappel utile pour les étapes minimales requises, mais ne devrait décourager personne de créer des étapes supplémentaires.

Dépend de votre environnement / langue de test, mais généralement si quelque chose dans la partie Arrangement échoue, une exception est levée et le test échoue à l'afficher au lieu de démarrer la partie Act. Donc non, je n'utilise généralement pas une deuxième partie Assert.

De plus, dans le cas où votre partie Arrange est assez complexe et ne lève pas toujours une exception, vous pourriez peut-être envisager de l'envelopper dans une méthode et d'écrire un test pour elle, afin d'être sûr qu'elle n'échouera pas (sans lancer une exception).

Je n'utilise pas ce modèle, car je pense faire quelque chose comme:

Arrange
Assert-Not
Act
Assert

Peut-être inutile, car vous savez que vous savez que votre partie Arrangement fonctionne correctement, ce qui signifie que tout ce qui se trouve dans la partie Arrange doit également être testé ou être assez simple pour ne pas avoir besoin de tests.

En utilisant l'exemple de votre réponse:

public void testEncompass() throws Exception {
    Range range = new Range(0, 5);
    assertFalse(range.includes(7)); // <-- Pointless and against DRY if there 
                                    // are unit tests for Range(int, int)
    range.encompass(7);
    assertTrue(range.includes(7));
}

Si vous voulez vraiment tout tester dans l'exemple, essayez plus de tests ... comme:

public void testIncludes7() throws Exception {
    Range range = new Range(0, 5);
    assertFalse(range.includes(7));
}

public void testIncludes5() throws Exception {
    Range range = new Range(0, 5);
    assertTrue(range.includes(5));
}

public void testIncludes0() throws Exception {
    Range range = new Range(0, 5);
    assertTrue(range.includes(0));
}

public void testEncompassInc7() throws Exception {
    Range range = new Range(0, 5);
    range.encompass(7);
    assertTrue(range.includes(7));
}

public void testEncompassInc5() throws Exception {
    Range range = new Range(0, 5);
    range.encompass(7);
    assertTrue(range.includes(5));
}

public void testEncompassInc0() throws Exception {
    Range range = new Range(0, 5);
    range.encompass(7);
    assertTrue(range.includes(0));
}

Parce que sinon, il vous manque tellement de possibilités d'erreur ... par exemple, après englober, la plage n'inclut que 7, etc. un autre ensemble de tests entièrement pour essayer d'englober 5 dans la plage ... à quoi s'attendre - une exception en englobant, ou la plage à être inchangée?

Quoi qu'il en soit, le fait est que s'il y a des hypothèses dans la loi que vous voulez tester, mettez-les dans leur propre test, oui?

J'utilise:

1. Setup
2. Act
3. Assert 
4. Teardown

Parce qu'une configuration propre est très importante.