Python-doctest vs. unittest [fermé]

j'utilise unittest presque exclusivement.

de temps en temps, je mets des trucs dans une corde Utilisable par doctest.

95% des cas d'essai sont unittest.

pourquoi? J'aime garder les cordes un peu plus courtes et plus précises. Parfois, les cas d'essai aident à clarifier une corde. La plupart du temps, les cas de test de l'application sont trop longs pour une corde.

un autre avantage des tests de documents est que vous pouvez vous assurer que votre code fait ce que votre documentation dit qu'il fait. Au bout d'un certain temps, les modifications logicielles peuvent faire en sorte que votre documentation et votre code fassent des choses différentes. :- )

je travaille comme bioinformaticien, et la plupart du code que j'écris est des scripts" Une fois, une tâche", code qui ne sera exécuté qu'une ou deux fois et qui exécute une seule tâche spécifique.

dans cette situation, écrire de grands questionnaires peut être exagéré, et les questionnaires sont un compromis utile. Ils sont plus rapides à écrire, et puisqu'ils sont généralement incorporés dans le code, ils permettent de toujours garder un oeil sur la façon dont le code devrait se comporter, sans avoir à ouvrir un autre fichier. C'est utile pour écrire un petit script.

Aussi, doctests sont utiles lorsque vous devez passer votre script à un chercheur qui n'est pas expert en programmation. Certaines personnes trouvent qu'il est très difficile de comprendre comment les unittests sont structurés; d'un autre côté, les doctests sont de simples exemples d'utilisation, de sorte que les gens peuvent simplement les copier et les coller pour voir comment les utiliser.

donc, pour reprendre ma réponse: les doctests sont utiles quand vous devez écrire de petits scripts, et quand vous devez les transmettre ou de les montrer à des chercheurs qui ne sont pas des informaticiens.

si vous êtes juste commencer avec l'idée de l'Unité de test, je commencerais par doctest parce qu'il est si simple à utiliser. Il fournit aussi naturellement un certain niveau de documentation. Et pour des tests plus complets avec doctest , vous pouvez placer des tests dans un fichier externe afin qu'il n'encombre pas votre documentation.

je suggérerais unittest si vous venez d'un arrière-plan D'avoir utilisé JUnit ou quelque chose de similaire, où vous voulez être en mesure pour écrire des tests unitaires en général de la même manière que vous avez été ailleurs.

utiliser les deux est une option valide et plutôt simple. Le module doctest fournit les méthodes DoctTestSuite et DocFileSuite qui créent une suite de test compatible unittest à partir d'un module ou d'un fichier, respectivement.

donc j'utilise les deux et j'utilise typiquement doctest pour des tests simples avec des fonctions qui nécessitent peu ou pas de configuration (types simples pour les arguments). En fait, je pense que quelques tests doctest aide documenter la fonction, plutôt que de détourner il.

mais pour les cas plus compliqués, et pour un ensemble plus complet de cas d'essai, j'utilise unittest qui fournit plus de contrôle et de flexibilité.

j'utilise unittest exclusivement; je pense que doctest embrouille trop le module principal. Cela a probablement à voir avec la rédaction de tests approfondis.

Je n'utilise pas doctest pour remplacer unittest. Bien qu'ils se chevauchent un peu, les deux modules n'ont pas la même fonction:

• j'utilise unittest comme cadre d'essai unitaire, ce qui signifie qu'il m'aide à déterminer rapidement l'impact de toute modification sur le reste du code.

• j'utilise doctest comme une garantie que les commentaires (à savoir les docstrings) sont toujours d'actualité à la version actuelle de code.

largement documenté les avantages du développement piloté par les tests que je reçois de unittest . doctest résout le danger beaucoup plus subtil d'avoir des commentaires périmés trompant le maintien du code.

Je n'utilise presque jamais de tests. Je veux que mon code soit auto-documenté, et les docstrings fournissent la documentation à l'utilisateur. L'OMI ajoute des centaines de lignes d'essais à un module, ce qui rend les cordons de doctrinal beaucoup moins lisibles. Je trouve aussi que les tests unitaires sont plus faciles à modifier au besoin.

Doctest peut parfois conduire à un mauvais résultat. Surtout quand la sortie contient des séquences d'évasion. Par exemple

def convert():
    """
    >>> convert()
    '\xe0\xa4\x95'
    """
    a = '\xe0\xa4\x95'
    return a
import doctest
doctest.testmod()

donne

**********************************************************************
File "hindi.py", line 3, in __main__.convert
Failed example:
    convert()
Expected:
    'क'
Got:
    '\xe0\xa4\x95'
**********************************************************************
1 items had failures:
   1 of   1 in __main__.convert
***Test Failed*** 1 failures. 

ne vérifie pas non plus le type de sortie. Il compare juste les chaînes de sortie. Par exemple il a fait un certain type rationnel qui imprime juste comme entier si c'est un nombre entier. Supposons alors que vous ayez une fonction qui renvoie la rationalité. Donc, un doctest ne différenciera pas si la sortie est rationnel nombre entier ou un nombre entier.

je préfère la découverte ("nez" et "py.test", en utilisant le premier actuellement).

doctest est agréable lorsque le test est aussi une bonne documentation, sinon ils ont tendance à encombrer le code trop.