Développeur freelance : gagnez en efficacité et en sérénité avec les tests unitaires

développeur freelance : gagnez en sérénité et en efficacité avec les tests unitaires

En tant que développeur freelance, vous avez certainement déjà entendu parler des tests unitaires, et peut-être même les pratiquez-vous déjà au quotidien. Si cela n’est pas encore le cas, cet article est fait pour vous !

Qu’est-ce qu’un test unitaire ? Quels avantages procure-t-il au développeur informatique ? Quelles sont les bonnes pratiques ainsi que les outils pour vous aider à créer des tests unitaires efficaces ? Freelance Republik lève le voile sur un aspect trop souvent négligé du métier de développeur, et pourtant ô combien essentiel.

 

Les bugs, le cauchemar du développeur freelance

Les développeurs, quel que soit leur langage, savent que plus un bug est détecté tôt et plus il est facile à corriger. Rien de pire en effet que de devoir débuguer un script développé des jours voire des semaines plus tôt, et possédant de multiples interdépendances avec d’autres scripts.

En pratique, il arrive souvent que le programmeur passe plus de temps à trouver l’origine du problème qu’à le corriger ! Passer une après-midi entière à s’arracher les cheveux (pour parfois finalement régler le problème en deux lignes de code) est particulièrement démoralisant en plus d’être inutilement chronophage.

La situation est pire encore si vous êtes développeur freelance. Car pour vous, le temps c’est de l’argent !

Si vous avez opté pour une facturation à l’heure ou à la journée, votre client pourrait vite s’agacer de cette situation, surtout si cela venait à se reproduire trop souvent. Et même si vous avez opté pour une facturation au forfait, la situation reste problématique puisqu’elle fait chuter votre taux horaire.

Sans parler de la potentielle baisse de crédibilité auprès de votre client, ni même de la deadline plus difficile à respecter… Les bugs sont vraiment une angoisse pour le freelance informatique !

 

Qu’est-ce qu’un test unitaire ?

Vous l’avez compris, en tant que développeur freelance il est essentiel pour vous de gérer au mieux le risque de bugs.

Pour autant, il n’est pas humainement possible de tester tous les cas de figures de manière systématique, et encore moins sur chacune des fonctionnalités de l’application. Ainsi, même le développeur freelance le plus scrupuleux du monde peut déployer des bugs en production, avec toutes les fâcheuses conséquences que cela peut avoir. Eh oui !

C’est là qu’entrent en jeu les tests unitaires. Un test unitaire a pour rôle de s’assurer du bon fonctionnement d’une partie précise de code, indépendamment de son contexte. Il retourne une erreur (de préférence détaillée) ou un succès, et alerte le développeur en cas de problème.

Pour maximiser son efficacité, chaque test unitaire doit être joué :

  • Lors du codage de la fonction associée afin de vous assurer que votre script fonctionne correctement et répond bien aux besoins ;
  • Après chaque modification de code ultérieure afin de vérifier qu’il n’y a pas de régressions. Et ce, qu’il s’agisse d’une modification directement de votre fait (ajout de feature, correction d’un bug…) ou non (mise-à-jour de framework, changement de version du langage de programmation…).

Les tests unitaires peuvent être lancés manuellement. Cette étape pouvant toutefois être fastidieuse, nous vous recommandons de les intégrer directement à votre système d’intégration continue afin qu’ils se lancent automatiquement. Nous aurons l’occasion d’aborder ce sujet plus en détails dans de prochains articles.

Si après avoir joué votre test unitaire vous constatez qu’il retourne une erreur, commencez par déterminer si cela vient d’un problème lié au code ou bien du test lui-même, puis réglez le problème. Dans tous les cas, pensez à maintenir vos tests unitaires à jour afin d’éviter toute régression future de votre programme.

Pas encore convaincu ? Découvrez notre top 5 des meilleurs arguments pour passer aux tests unitaires :

 

Développeurs freelances, pourquoi adopter les tests unitaires ?

1-    Détection rapide des erreurs

Nous l’avons vu, les tests unitaires permettent de mettre immédiatement en exergue les bugs de votre application. Et comme chaque code ne teste qu’une petite portion de votre code, vous savez précisément à quel endroit l’erreur se produit. Le débogage en est ainsi grandement facilité !

2-    Un gain de temps pour les testeurs de l’application

Tester une application de fond en comble est une tâche particulièrement chronophage. Il faut mettre en place tout un tas de process ou de check-list afin de s’assurer que TOUTES les fonctionnalités de l’application ont bien été testées, y compris dans leurs cas les plus problématiques voire improbables. Et ce, à chaque fois que nécessaire.

Que se passe-t-il si je saisis un chiffre dans un champ qui n’est sensé recevoir que des lettres ? Ou si je saisis une adresse mail non valide ? Est-ce que l’utilisateur sera bien connecté après avoir saisi ses identifiants ? Etc, etc.

Les tests unitaires, s’ils sont bien conçus, prennent en compte tous les cas possibles. Mieux encore, ils peuvent être rejoués à volonté ! Cela représente, là encore, un gain de temps considérable pour les testeurs.

3-    Gagnez en sérénité !

Être développeur freelance est une grande source de stress au quotidien. Entre la gestion de l’entreprise, les relations avec les clients, la recherche de nouveaux contrats, le moral n’est pas toujours au beau fixe ! Et quand en plus il faut ajouter des débogages longs et fastidieux, ce peut être la goutte de trop.

Grâce à vos tests unitaires, vous serez rassuré sur la qualité de votre code, et ce même après une mise-à-jour ou le développement de nouvelles fonctionnalités. De quoi être plus serein au quotidien !

4-    Des clients comblés

Grâce à vos tests unitaires, vous pourrez vous montrer pro-actif sur la résolution des problèmes, et les déceler avant de faire un déploiement en production. Vos clients apprécieront la stabilité de votre code. Vous pouvez même en faire un argument commercial !

5-    Meilleure compréhension du code

Il n’est pas rare de travailler à plusieurs sur un même projet, ou de récupérer un projet déjà démarré par un autre développeur freelance. Selon les cas, et même s’il existe des bonnes pratiques, la transition peut s’avérer compliquée.

Si vous travaillez en équipe, invitez les autres développeurs à recourir aux tests unitaires eux aussi. En effet, leur lecture permet également de faciliter la compréhension du code : comment s’utilise la méthode X, quelle est la subtilité de cette partie de code, etc.

Cela est d’autant plus vrai si la documentation n’est pas systématiquement mise à jour (ce qui, avouons-le, est malheureusement bien souvent le cas) ou si le code est peu commenté.

 

Les bonnes pratiques du test unitaire

Maintenant que vous êtes convaincu de l’intérêt de recourir aux tests unitaires en tant que développeur freelance, voyons maintenant quelques bonnes pratiques :

Créer des tests unitaires très spécifiques

C’est un pléonasme, et pourtant trop de développeurs oublient ce point essentiel : un test unitaire doit véritablement être… unitaire. C’est-à-dire ne tester qu’une petite portion de code, en l’isolant totalement de son contexte.

Votre méthode est trop complexe ou trop volumineuse ? Profitez-en pour la refactoriser, la qualité de votre code n’en sera que meilleure ! L’interdépendance entre les tests est une chose à éviter : plus ils seront dépendants entre eux, et plus il vous sera difficile de trouver l’origine du problème !

Ecrire les tests avant le code

Le problème d’écrire les tests après avoir codé la fonctionnalité, c’est non seulement que vous allez fortement vous inspirer de votre code pour le test, mais en plus vous risquez également de remettre cette action à plus tard… Et finalement oublier de rédiger votre test unitaire !

Pour pallier à cela, vous pouvez écrire les tests en premier. Cette méthode est appelée Test Driven Development, ou TDD pour les intimes.

Utiliser les mocks

Pour qu’un test unitaire soit efficace, il faut absolument qu’il soit déconnecté de tout contexte. Y compris de la base de données, des services web divers et autres modules. En effet, à cause de ces dépendances, votre test unitaire pourrait vous retourner une erreur qui n’est pas de son fait, ou tout simplement être bien plus long à jouer.

Pour éviter cette situation, vous pouvez recourir aux mocks. Ils ont pour rôle de simuler le comportement d’autres modules. Vous pouvez ainsi simuler une erreur difficile à reproduire, un retour de base de données…

Soyez toutefois vigilants avec leur utilisation. Il n’y a en effet rien de pire qu’un test qui échoue ponctuellement, sans raison apparente. Et bien souvent, les mocks sont en cause. Aussi, assurez-vous de bien les utiliser ! Et veillez également à ce que vos mocks simulent bien le comportement attendu, au risque que votre test retourne un succès alors que votre application plante, ou inversement…

A noter qu’il existe des frameworks de mocks (exemple : Easy Mock) pour vous aider, même s’il est toujours intéressant de savoir les créer soi-même.

Utiliser des outils facilitant les tests unitaires

Afin de faciliter la mise en place de vos tests unitaires, vous pouvez recourir à un outil spécialement conçu pour cela. Le terme générique de cet outil est xUnit, où x est généralement remplacé par l’initiale du langage.

Quelques exemples :

  • PHP : PHPUnit ou encore Atoum
  • C++ : Cppunit
  • C : Cunit
  • Ruby : Test ::Unit
  • Python : Unittest ou encore PyUnit
  • JavaScript : JSUnit, QUnit ou encore Unit.js
  • Java : JUnit et TestNG

Cette liste n’est bien entendu qu’un petit aperçu, il existe de nombreux autres xUnits.

Automatiser les tests unitaires

C’est bien connu, un bon développeur est un développeur fainéant ! Parce que si vous devez lancer tous vos tests unitaires manuellement, un par un, il y a fort à parier que vous oublierez tôt ou tard d’en lancer un. Après avoir passé des heures à créer des tests unitaires pour couvrir l’ensemble de votre site, ce serait dommage, non ?

Pour automatiser leur lancement, vous pouvez utiliser une plateforme d’intégration continue comme nous l’évoquions plus haut. En voici une liste non exhaustive : Jenkins, Gitab CI ou encore Travis CI.

Des tests rapides et faciles à lancer

Pour rappel, nous vous invitons à lancer (très) régulièrement vos tests afin de pouvoir réagir au plus vite en cas de problème. Nous vous recommandons même de les automatiser en les incluant à votre système d’intégration continue.

Attention toutefois aux tests trop lents : quoi de pire que d’attendre plusieurs minutes (ou heures !) pendant leur exécution ? Vous perdrez immanquablement en efficacité et en concentration.

Il en va de même si vous devez sans cesse modifier des fichiers de configuration pour pouvoir les lancer en local ou séparément les uns des autres.

Afin d’éviter cela, nous vous recommandons là encore de suivre les bonnes pratiques pour la construction de vos tests unitaires. Évitez par exemple tout accès à des fichiers ou encore à la base de données, et recourez à des mocks pour les simuler.

Des erreurs faciles à comprendre

Nous abordons ici une autre subtilité essentielle dans les tests unitaires : la gestion du retour fourni.

Si vous retournez le même message d’erreur quelle que soit la raison d’échec du test, vous ne serez guère plus avancé. Évitez les messages trop généralistes.  Prenez le temps de retourner des messages d’erreur spécifiques, adaptés au contexte. En cas d’échec de votre test, vous saurez alors ainsi immédiatement d’où provient l’erreur et pourrez la corriger en un rien de temps.

 

Conclusion

Les tests unitaires, s’ils sont bien conçus et bien intégrés dans le processus de développement, font gagner beaucoup de temps au développeur. Ils lui permettent en outre d’être plus serein et facilite les mises-à-jour de son code.

Attention, les tests unitaires ne couvrent qu’un niveau de votre code et ne se suffisent à eux-mêmes. Pour être certain que votre application ne présente pas le moindre bug, vous devez ajouter d’autres niveaux de test, comme par exemple les tests d’intégration. Ces derniers ont justement pour rôle de tester les dépendances entre plusieurs modules.

Ce sujet vous intéresse ? Faites-le nous savoir via les commentaires ! Nous serons ravis de publier d’autres articles autour de cette thématique passionnante, et pourtant trop souvent jugée secondaire.

A lire aussi:

  1. Retour d’expérience: Jonathan, développeur front-end AngularJS en freelance
Développeur freelance : gagnez en efficacité et en sérénité avec les tests unitaires
Noter cet article

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *