Pratiques exemplaires en matière de désignation des unités d'essai [terminé]

j'aime suivre le " devrait " norme d'appellation pour essais tout en nommant le montage d'essai après l'unité à l'essai (c'est-à-dire la classe).

pour illustrer (en utilisant C# et 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));
  }
}

Pourquoi "Devrait" ?

je trouve qu'il force le test des écrivains pour nom le test avec une phrase du genre "Devrait [être dans un certain état] [après/avant/lorsque] [action]"

Oui, l'écriture "Devrait" partout ne obtenir un peu répétitif, mais comme je l'ai dit il oblige les auteurs à penser dans le bon sens (donc peut être bon pour les novices). De plus, il en résulte généralement un nom de test Anglais lisible.

mise à Jour :

J'ai remarqué que Jimmy Bogard est aussi un fan de "Devrait" et a même une bibliothèque de test unité appelé Devrait .

mise à Jour (4 ans plus tard...)

pour les intéressés, mon approche des tests de nommage a évolué au fil des ans. Un des problèmes avec le devrait modèle que je décris ci-dessus comme son pas facile de savoir à un coup d'oeil quelle méthode est à l'essai. Pour OOP je pense qu'il est plus logique de commencer le nom de test avec la méthode sous test. Pour une classe bien conçue il devrait en résulter des noms de méthode d'essai lisibles. J'utilise maintenant un format similaire à <method>_Should<expected>_When<condition> . Évidemment, selon le contexte, vous pouvez vouloir substituer les verbes devrait/quand pour quelque chose de plus approprié. Exemple: Deposit_ShouldIncreaseBalance_WhenGivenPositiveValue()

j'aime ce style de nom:

OrdersShouldBeCreated();
OrdersWithNoProductsShouldFail();

et ainsi de suite. Il est vraiment clair pour un non-testeur ce que le problème est.

Kent Beck suggère:

• un montage d'essai par 'unité' (classe de votre programme). Les fixtures de Test sont des classes elles-mêmes. Le nom du montage d'essai doit être:

  [name of your 'unit']Tests
  

• les cas D'essai (les méthodes de montage d'essai) portent des noms comme:

  test[feature being tested]
  

, par exemple, ayant la classe suivante:

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

    // other methods and properties
}

un gabarit d'essai serait:

class PersonTests {

    testAgeCalculationWithNoBirthDate() { ... }

    // or

    testCalculateAge() { ... }
}

Les Noms De Classe . Pour les noms de Fixtures de test, je trouve que "Test" est assez commun dans le langage omniprésent de nombreux domaines. Par exemple , dans un domaine d'ingénierie: StressTest , et dans un domaine cosmétique: SkinTest . Désolé de ne pas être D'accord avec Kent, mais en utilisant "Test" dans Mes fixtures de test ( StressTestTest ?) est source de confusion.

"unité" est également beaucoup utilisé dans les domaines. Par exemple: MeasurementUnit . Est une classe appelée MeasurementUnitTest un test de " mesure" ou "MeasurementUnit"?

J'aime donc utiliser le préfixe" Qa " pour toutes mes classes d'essai. Par exemple: QaSkinTest et QaMeasurementUnit . Il n'est jamais confondu avec des objets de domaine, et l'utilisation d'un préfixe plutôt que d'un suffixe signifie que toutes les fixtures de test vivent ensemble visuellement (utile si vous avez des contrefaçons ou d'autres classes de soutien dans votre projet de test)

espaces de noms . Je travaille en C# et je garde mes classes de test dans le même espace de noms que la classe, elles sont à l'essai. C'est plus pratique que d'avoir des namespaces de test séparés. Bien sûr, les classes de test sont dans un projet différent.

noms des méthodes d'essai . J'aime nommer mes méthodes Whenxxx_expectyy. Il rend la condition préalable claire, et aide à la documentation automatisée (a la TestDox). Cela est similaire aux conseils sur le Blog Google testing, mais avec plus de séparation des conditions préalables et des attentes. Par exemple:

WhenDivisorIsNonZero_ExpectDivisionResult
WhenDivisorIsZero_ExpectError
WhenInventoryIsBelowOrderQty_ExpectBackOrder
WhenInventoryIsAboveOrderQty_ExpectReducedInventory

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

pour les noms de méthode d'essai, je trouve personnellement très utile d'utiliser des noms verbeux et auto-documentés (en plus des commentaires Javadoc qui expliquent plus en détail ce que fait le test).

j'ai récemment proposé la convention suivante pour nommer mes tests, leurs classes et contenant des projets afin de maximiser leurs descriptivités:

disons que je teste la classe paramètres dans un projet dans le MyApp.La sérialisation espace de noms.

D'abord je vais créer un projet d'essai avec le MyApp.Sérialisation.Les Tests de espace de noms.

Dans le cadre de ce projet et bien sûr de l'espace de noms, je vais créer une classe appelée IfSettings (sauvegardée comme IfSettings.cs).

disons que je teste la méthode SaveStrings () . - >Je vais nommer le test CanSaveStrings () .

lors de cet essai, il affichera le titre suivant:

MyApp.Sérialisation.Test.IfSettings.CanSaveStrings

je pense que cela me dit très bien, ce qu'il teste.

bien sûr, il est utile qu'en anglais le nom "Tests" est le même que le verbe "tests".

il n'y a pas de limite à votre créativité pour nommer les tests, de sorte que nous obtenons des titres de phrases complètes pour eux.

habituellement, les noms de Testnames devront commencer par un verbe.

exemples:

• détecte (p.ex. Détectsinvaliduserinput)
• lancers (p.ex. lanceurs)
• Will (e.g. WillCloseTheDatabaseAfterTheTransaction)

etc.

une autre option consiste à utiliser" that "au lieu de"if".

ce dernier me sauve des touches cependant et décrit plus exactement ce que je fais, puisque je ne sais pas, que le comportement testé est présent, mais am testing si il est.

[ Modifier ]

après avoir utilisé la convention de nommage ci-dessus pour un peu plus longtemps maintenant, j'ai trouvé, que le préfixe si peut être déroutant, en travaillant avec des interfaces. Il se trouve que la classe de test IfSerializer.cs ressemble beaucoup à la interface ISerializer.cs dans l'onglet"Ouvrir les fichiers". Cela peut devenir très gênant lors de la commutation de va-et-vient entre les tests, la classe testée et son interface. En conséquence, je choisirais maintenant comme préfixe plutôt que si comme préfixe.

en outre, j'utilise maintenant-seulement pour les méthodes dans mes classes d'essai comme il n'est pas considéré comme la meilleure pratique ailleurs - le "_" pour séparer les mots dans ma méthode d'essai noms tels que:

• [Test] public void detects_invalid_User_Input () *

je trouve cela plus facile à lire.

[ Final Edition ]

j'espère que cela donnera lieu à d'autres idées, car je considère que le fait de nommer des tests d'une grande importance peut vous épargner beaucoup de temps qui autrement auraient été consacrés à essayer de comprendre ce que les tests sont en train de faire (par exemple, après avoir repris une projet après une interruption prolongée).

j'utilise Vu-Quand-Puis concept. Jetez un oeil à ce court article http://cakebaker.42dh.com/2009/05/28/given-when-then / . Article décrit ce concept en termes de BDD, mais vous pouvez l'utiliser dans TDD aussi bien sans aucun changement.

je pense que l'une des choses les plus importantes est d'être cohérent dans votre convention de nommage (et d'accord avec les autres membres de votre équipe). À plusieurs reprises, je vois des tas de conventions différentes utilisées dans le même projet.

dans VS + NUnit je crée habituellement des dossiers dans mon projet pour grouper les tests fonctionnels ensemble. Ensuite, je crée des classes d'appareils de test et je les nomme d'après le type de fonctionnalité que je teste. Les méthodes [D'essai] sont nommées comme suit: 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

je devrais ajouter que le fait de garder vos tests dans le même paquet mais dans un répertoire parallèle à la source testée élimine le gonflement du code une fois que vous êtes prêt à le déployer sans avoir à faire un tas de motifs d'exclusion.

personnellement, j'aime les meilleures pratiques décrites dans "JUnit Guide de Poche" ... c'est dur de battre un livre écrit par le co-auteur de JUnit!

le nom du cas d'essai pour la classe Foo devrait être FooTestCase ou quelque chose comme elle (FooIntegrationTestCase ou FooAcceptanceTestCase) - car il s'agit d'un cas d'essai. voir http://xunitpatterns.com/ pour certaines conventions de nommage comme test, cas de test, banc d'essai, méthode d'essai, etc.