Les tests en bioinformatique

Tester est-ce douter ?

Aujourd'hui on va par­ler d'un truc très connu des infor­ma­ti­ciens mais encore trop peu connu en bio-infor­ma­tique : les tests.

Cette pra­tique est pour­tant conseillée dans le guide du bon bro­in­for­ma­ti­cien . Alors, qu'est ce qu'un test ?

Un test désigne une pro­cé­dure de véri­fi­ca­tion d'un sys­tème. Son objec­tif prin­ci­pal est d'identifier un nombre maxi­mum de com­por­te­ments pro­blé­ma­tiques du logi­ciel afin d'en aug­men­ter la qua­li­té (si les pro­blèmes iden­ti­fiés lors des tests sont cor­ri­gés). Mer­ci Wiki­pé­dia !

Il existe 3 types de tests : les tests uni­taires, les tests fonc­tion­nels et les tests d'intégration.
Les tests fonc­tion­nels cor­res­pondent la phase de tests de tout bon bio­in­for­ma­ti­cien à la fin du déve­lop­pe­ment, qui consistent à véri­fier que toute les fonc­tion­na­li­tés du pro­gramme deman­dé sont sup­por­tées.
Les tests d'intégration visent à s'assurer du bon fonc­tion­ne­ment de la mise en œuvre conjointe de plu­sieurs uni­tés de pro­gramme.
Les tests uni­taires visent à tes­ter une uni­té de code. Cette défi­ni­tion ne nous aide pas beau­coup car il faut encore défi­nir ce qu'est une uni­té de code ; selon les cas une uni­té de code peut signi­fier une classe, une fonc­tion ou une ins­truc­tion. Ce sont ces uni­tés de code qui s'articule entre elle pour faire un code com­plexe. Dans cet article nous nous concen­tre­rons sur les tests uni­taires car ce sont les tests les plus simple d'utilisation et les plus per­for­mants pour garan­tir la qua­li­té d'un pro­gramme.

À quoi sert un test unitaire ?

Un test uni­taire sert à véri­fier en fonc­tion de cer­taines don­nées four­nies en entrée d’une uni­té de code que les don­nées qui en sortent ou les actions qui en découlent sont conformes aux spé­ci­fi­ca­tions de cette uni­té.

Pourquoi tester ?

Met­tons nous bien d'accord, il est pos­sible de réa­li­ser du très bon code sans test uni­taire et il est aus­si pos­sible de réa­li­ser du très mau­vais code (peu effi­cace, laid) qui soit tes­té. Mais les tests uni­taires sont la base du pro­ces­sus d'amélioration de la qua­li­té du code.

Les tests per­mettent de véri­fier la qua­li­té du code de façon auto­ma­tique. Ils aident aus­si à amé­lio­rer la confiance dans la qua­li­té du code déve­lop­pé par d'autre et donc le tra­vail en équipe.

Contrai­re­ment aux tests empi­riques (manuels) , les tests uni­taires per­mettent de tes­ter l'ensemble de son code en une seule com­mande, ce qui entraine un gain de robus­tesse et de temps de debug.

Grace aux tests auto­ma­ti­sés il est aus­si pos­sible de connaître quel pour­cen­tage de son code est tes­té. On parle de cou­ver­ture de code. Cette cou­ver­ture de code est un bon indice de la qua­li­té du code et des tests.

Comment bien tester son code ?

Pour bien tes­ter une uni­té de code il faut véri­fier que dans un maxi­mum de cas l'unité de code ren­voie le résul­tat atten­du. Pour cela il y a plu­sieurs bonnes pra­tiques à res­pec­ter :

• Il faut véri­fier que le sys­tème tes­té est véri­ta­ble­ment uni­taire, c'est à dire qu'il n'est pas lié à d'autres uni­tés de code.
• Si une classe est com­plexe à tes­ter : il est temps de fac­to­ri­ser son code en plu­sieurs modules !
• Les tests doivent s’exécuter le plus rapi­de­ment pos­sible pour être le plus faci­le­ment uti­li­sables.
• Faites bien atten­tion au code de vos tests pour qu'il soient faci­le­ment com­pré­hen­sible.
• Ne tes­tez qu’un com­por­te­ment à la fois. Soyez rai­son­nable et gar­dez le test simple, lisible et concen­tré sur ce com­por­te­ment.

Exemple de test en bioinformatique

Allons voir Antoine qui tra­vaille avec son col­lègue Ber­nard sur un pro­jet de déve­lop­pe­ment de logi­ciel per­met­tant d'afficher des fichiers VCF. Ils déve­loppent cha­cun un module : Antoine est char­gé du par­seur de fichier VCF et Ber­nard est char­gé de l'interface gra­phique. Ber­nard uti­lise donc le module déve­lop­pé par Antoine. Avant d'utiliser le module d'Antoine, Ber­nard va pou­voir exé­cu­ter les tests ce qui lui per­met­tra d'avoir confiance dans le code et dans le fonc­tion­ne­ment de l'API pour construire son inter­face gra­phique. Il est même pos­sible qu'ils se soient mis d'accord sur les tests avant le début du déve­lop­pe­ment, on parle dans ces cas la de Test Driven Deve­lop­ment (TDD) car les tests entraînent le déve­lop­pe­ment.

Durant le déve­lop­pe­ment de l'interface ils pour­ront mettre en place des tests fonc­tion­nels et des tests d'intégration.

Un exemple de test unitaire

Nous allons main­te­nant prendre un exemple de test uni­taire en pseu­do code

[/​crayon]

Ce code va ren­voyer

[/​crayon]

pour cha­cun des tests, ce qui montre que pour l'ensemble des cas tes­tés la réponse est celle que l'on s'attendait à voir.

L'objectif des tests uni­taires est de tes­ter le fonc­tion­ne­ment nor­mal d'une uni­té de code mais sur­tout de tes­ter ses cas limites. Ce sont sou­vent les cas limites qui sont oubliés par les déve­lop­peurs et pro­voquent des bugs.

Quelques outils pour faciliter les tests

Dans presque tout les lan­gages il existe des librai­ries qui pour­ront vous faci­li­ter l'écriture de tests uni­taires. Pour le lan­guage python cet article est super bien : http://sametmax.com/un-gros-guide-bien-gras-sur-les-tests-unitaires-en-python-partie‑1/ . En R vous pour­rez aller voire cet article : http://www.win-vector.com/blog/2019/03/unit-tests-in‑r/ .

Dans la suite de cet article je vais pré­sen­ter quelques outils lan­gage agnos­tique (indé­pen­dant du lan­gage) pour faci­li­ter les tests.

Balto

https://​github​.com/​L​o​t​h​i​r​a​l​d​a​n​/​b​a​lto

Bal­to est un test run­ner qui per­met de regrou­per des outils test dans une inter­face gra­phique pra­tique.

Cypress

https://​www​.cypress​.io/

Cypress est un outil per­met­tant de tes­ter le front end d'applications web très faci­le­ment et de créer dif­fé­rents sce­na­rii qui pour­ront ensuite être lan­cer auto­ma­ti­que­ment.

Conclusion

Tes­ter n'améliore pas for­cé­ment la qua­li­té du code et il est pos­sible de faire du bon code sans tests mais les tests per­mettent de détec­ter plus faci­le­ment des erreurs dans le code, amé­liorent la confiance dans la qua­li­té du code, rendent plus facile le tra­vail col­lec­tif et aide à reve­nir plus faci­le­ment dans un pro­jet lais­sé de coté . Donc n'hésitez plus, tes­ter !

mer­ci Yoann M, Zazo0o, et Aze­rin pour leur relec­ture.

Affiche d'illustration pro­ve­nant de Com​mits​trip​.com