Flux de travail de test Haskell
je viens de démarrer un nouveau projet Haskell et je voulais mettre en place un bon workflow de test dès le début. Il semble que Haskell a beaucoup d'excellents et uniques outils de test et de nombreuses façons différentes de les intégrer.
j'ai regardé dans:
- HUnit
- QuickCheck
- benchpress
- HPC
- complexité
qui semblent tous très bien fonctionner dans leurs domaines, mais je suis à la recherche d'une approche complète pour tester et je me demandais ce qui a bien fonctionné pour d'autres personnes.
4 réponses
obtenir les tests unitaires, la couverture de code, et les benchmarks droit est principalement sur le choix des bons outils.
- test-cadre offre un one-stop-shop pour exécuter tous vos HUnit cas de test de et de QuickCheck toutes les propriétés d'un harnais. La couverture du Code
- est intégrée dans GHC sous la forme de l'outil HPC . Le critère
- fournit une excellente analyse comparative des machines
je vais utiliser comme exemple d'exécution un paquet que je viens de commencer à activer avec les tests unitaires, la couverture du code et les benchmarks:
http://github.com/ekmett/speculation
vous pouvez intégrer vos tests et benchmarks directement dans votre fichier cabal en ajoutant des sections pour eux, et en les masquant derrière des drapeaux pour qu'ils ne le fassent pas pour que chaque utilisateur de votre la bibliothèque doit avoir accès (et vouloir utiliser pour elle-même) à la version exacte des outils de test que vous avez choisis.
http://github.com/ekmett/speculation/blob/master/speculation.cabal
alors, vous pouvez dire à cabal comment exécuter votre suite de test. comme le test cabal n'existe pas encore -- nous avons un étudiant qui travaille dessus pour l'été de code de cette année! -- le meilleur mécanisme que nous avons est Voici comment faire utiliser la cabale de l'utilisateur mécanisme de crochet. Cela signifie passer à une construction "sur mesure" avec cabal et configurer un testHook. Un exemple de testHook qui exécute un programme de test écrit avec test-framework, puis applique hpc pour le profiler peut être trouvé ici:
http://github.com/ekmett/speculation/blob/master/Setup.lhs
et ensuite vous pouvez utiliser test-framework pour regrouper les tests QuickCheck et HUnit en un seul programme:
http://github.com/ekmett/speculation/blob/master/Test.hs
le fichier cabal il est prudent d'activer-fhpc pour activer le test de couverture du code, puis le testHook dans Setup.lhs exécute manuellement hpc et écrit sa sortie dans votre dir dist.
pour le benchmarking, l'histoire est un peu plus manuelle, il n'y a pas d'option "Cabal benchmark". Vous pouvez connecter vos points de repère dans votre crochet de test, mais j'aime les exécuter par la main, car le Critère a de nombreux rapports graphiques options. Vous pouvez ajouter vos benchmarks au fichier cabal comme indiqué ci-dessus, leur donner des drapeaux de compilation séparés, les cacher derrière un drapeau cabal, puis utiliser le critère pour faire tout le levage lourd:
http://github.com/ekmett/speculation/blob/master/Benchmark.hs
vous pouvez alors exécuter vos benchmarks à partir de la ligne de commande et obtenir des fenêtres pop-up KDE avec des résultats de benchmark, etc.
puisque dans la pratique vous vivez dans la cabale de toute façon tout en développant le code Haskell, il est très logique d'intégrer votre chaîne d'outils avec elle.
Modifier : Cabale test à l'appui maintenant, n'existe pas. Voir http://www.haskell.org/cabal/release/cabal-latest/doc/users-guide/developing-packages.html#test-suites
L'approche est avocat à RWH ch 11 et dans XMonad est à peu près:
- indiquer toutes les propriétés du système dans QuickCheck
- Show de la couverture de test avec le HPC.
- Confirmer l'espace de comportement avec les tas de profilage .
- confirmer le comportement fil / parallèle avec ThreadScope .
- confirmer le comportement microbenchmark avec critère .
une fois vos invariants majeurs établis via QuickCheck, vous pouvez commencer à refactoriser, en déplaçant ces tests dans les invariants de type.
pratiques pour soutenir vos efforts:
- exécuter une régression QuickCheck simplifiée sur chaque commit.
- publier les détails de la couverture HPC.
Le test-cadre package est vraiment génial. Vous pouvez facilement intégrer les tests de HUnit et de QuickCheck, et obtenir des exécutables qui n'exécutent que des suites spécifiées, basées sur des options de ligne de commande, avec des cibles de sortie multiples.
les tests et le profilage sont des bêtes différentes. Pour le profilage j'avais crée un exécutable qui souligne juste la partie que vous voulez de profil, et juste en regardant attentivement les résultats de profilage construit et exécute (avec-prof-auto-all pour la compilation et +RTS-p pour un drapeau runtime).
pour les tests, je me fie aux propriétés de HUnit et QuickCheck et j'utilise le Haskell Test Framework pour collecter automatiquement tous les tests unitaires et toutes les propriétés QuickCheck.
Avertissement: je suis le développeur principal du Haskell Framework de Test.