T: / Articles techniques / Tous langages
Comment s’assurer que son code fait ce qu’on attend de lui… maintenant… et surtout plus tard !
Avant même d’écrire une ligne de code, toute personne qui programme se confronte à une question essentielle : comment s’assurer que ce qu’on écrit fonctionne vraiment ?
Car un programme peut “tourner” sans erreur apparente, tout en produisant des résultats faux, partiels ou imprévisibles. Tester son code, c’est justement apprendre à ne pas faire confiance à la première impression. C’est vérifier, anticiper, et garantir que le programme reste fiable au fil du temps.
Dans cet article, on verra :
Quand on apprend à programmer, on se concentre surtout sur une chose : faire en sorte que le code fonctionne. Mais “fonctionner” ne veut pas dire “bien fonctionner”.
Un programme peut afficher un résultat, sans que ce résultat soit juste. Ou encore, il peut marcher dans un cas précis… et se tromper complètement dans un autre.
C’est pour ça qu’il faut tester : pour vérifier que le code réagit correctement dans plusieurs situations.
Quand on teste, on prend le temps de regarder comment le programme se comporte. On change les valeurs, on observe, on réfléchit à ce qui devrait se passer. C’est une étape essentielle pour progresser : elle aide à comprendre la logique de ce qu’on écrit.
Tester, ce n’est pas seulement “voir si ça marche”, c’est apprendre à douter du résultat et à poser la question : “Et si je changeais les données ? Est-ce que mon code réagirait toujours bien ?”
Les erreurs en programmation ne sont pas toujours visibles. Parfois, tout a l’air correct à l’écran, mais une simple ligne mal placée provoque un mauvais calcul ou un oubli.
Les tests permettent de repérer ces erreurs discrètes avant qu’elles ne causent de vrais problèmes.
Tester son code, c’est aussi éviter de chercher les erreurs plus tard. Corriger une faute juste après l’avoir repérée est simple. Mais revenir sur un code écrit la veille ou la semaine dernière, c’est souvent plus long et plus confus.
Tester régulièrement, c’est donc un moyen de travailler plus sereinement, sans se demander sans cesse “est-ce que ça va encore marcher ?”.
Quand plusieurs personnes travaillent sur le même projet, les tests servent de repères communs. Ils montrent ce que le code est censé faire, sans qu’il soit nécessaire de tout expliquer à la main.
C’est une forme de langage universel : on peut lire un test et comprendre l’intention derrière le code.
Il existe deux grandes manières de tester : manuellement et automatiquement.
La première repose sur l’observation et l’expérimentation. La seconde, sur la rigueur et la répétition.
Les deux approches sont complémentaires, et ensemble, elles permettent de créer des programmes plus fiables.
Tester manuellement, c’est la première étape naturelle. On exécute le code, on observe ce qui se passe, on vérifie les valeurs affichées. C’est un peu comme manipuler un prototype pour voir s’il réagit correctement.
Comment tester son code manuellement ? Cela dépend du langage utilisé et du type de programme :
console.log().python mon_script.py. Les tests manuels se font alors en observant les sorties du programme dans le terminal.Exemples de code
Considérons qu’on crée une fonction pour réaliser une addition de 2 nombres, on va pouvoir tester plusieurs combinaisons :
On peut donc écrire les tests de la façon suivante :
PHP
function addition(int $a, int $b) {
return $a + $b;
}
echo addition(1, 1);
echo addition(0, 1);
echo addition(1, 0);
echo addition(0, 0);
echo addition(15, 23);
// Et par exemple vérifier que ce code renvoie une erreur
echo addition('quinze', 3); // Car on attend un nombre entier et non une chaine de caractères
Et on vérifie dans le navigateur l’affichage associé.
JavaScript
function addition(a, b) {
return a + b;
}
console.log(addition(1, 1));
console.log(addition(0, 1));
console.log(addition(1, 0));
console.log(addition(0, 0));
console.log(addition(15, 23));Et on vérifie dans la console du navigateur l’affichage associé.
Python
def addition(a, b):
return a + b
print(addition(1, 1))
print(addition(0, 1))
print(addition(1, 0))
print(addition(0, 0))
print(addition(15, 23))Et on vérifie dans le terminal l’affichage associé.
Limites des tests manuels
Ces tests rapides sont parfaits pour apprendre et comprendre.
Mais dès qu’un programme contient plusieurs fonctions ou des conditions complexes, le test manuel devient vite long et répétitif. On oublie facilement certains cas, et surtout, il faut tout recommencer à chaque modification.
Avant d’aller plus loin et d’automatiser ces vérifications, il existe une étape importante : définir clairement ce qu’on veut tester.
Avant même de penser à automatiser les vérifications, il est important de choisir quoi tester.
C’est ce qu’on appelle un jeu de tests : une liste de situations différentes que le programme doit savoir gérer (c’est ce qu’on a dans les exemples de code précédents).
Un bon jeu de tests permet de vérifier que le code fonctionne non seulement dans les cas simples, mais aussi dans les cas particuliers ou imprévus.
Penser aux différents cas possibles
Reprenons un exemple courant : on écrit une fonction qui cherche un élément dans un tableau ou une liste. Pour être sûr que cette fonction fonctionne correctement, il ne suffit pas de tester le cas “normal”.
On doit aussi imaginer d’autres situations :
Ces cas servent à vérifier ce qu’on appelle les limites : les zones où le code risque de « mal » se comporter.
Plus ces situations sont variées, plus ton jeu de tests te donne une vision fiable du fonctionnement réel du programme.
Pourquoi c’est important ?
Quand on débute, on teste souvent uniquement les valeurs “évidentes”. Mais un bon jeu de tests pousse à réfléchir plus loin : Qu’est-ce qui pourrait faire échouer ma fonction ?
Cela évite de laisser passer des erreurs discrètes, et cela prépare le terrain pour de futurs ajouts ou modifications du code.
A savoir pour les challenges Tainix
Dans certains modules pédagogiques de Tainix, notamment ceux conçus pour les écoles, un jeu de tests complet est fourni avec chaque challenge.
Ces tests seront à exécuter pour vérifier le code produit et indiquer précisément quels cas sont validés ou échoués.
Une fois ce jeu de tests défini, on peut aller plus loin : laisser le programme exécuter ces vérifications automatiquement.
Tester automatiquement, c’est un peu comme apprendre à son programme à se vérifier lui-même. Au lieu d’exécuter chaque test à la main, on écrit du code qui a pour rôle… de tester du code !
L’idée peut paraître étrange au début, mais elle devient vite indispensable : plutôt que de tout vérifier à la main à chaque modification, on laisse un outil s’en charger pour nous.
Ces outils sont appelés des frameworks de tests. Un framework est un ensemble de règles et de fonctions prêtes à l’emploi, qui permettent d’écrire et d’exécuter des tests facilement.
Chaque langage de programmation a le sien :
Grâce à ces outils, on peut écrire une série de “mini-contrôles” que le programme va exécuter automatiquement pour vérifier que tout fonctionne comme prévu.
Même si les exemples qui suivent peuvent sembler un peu techniques au premier regard, leur but n’est pas d’être compris dans les moindres détails. Ils servent avant tout à découvrir la logique et la syntaxe des frameworks de tests unitaires : un test vérifie un résultat attendu, et indique s’il est correct ou non.
PHP et PHPUnit
use PHPUnit\Framework\TestCase;
class AdditionTest extends TestCase {
public function testAddition() {
$this->assertEquals(5, addition(2, 3));
}
}
// À exécuter avec la commande "phpunit"JavaScript et Jest
function addition(a, b) {
return a + b;
}
test('addition de 2 et 3', () => {
expect(addition(2, 3)).toBe(5);
});
// À exécuter avec la commande "npx jest"Python
import unittest
def addition(a, b):
return a + b
class TestAddition(unittest.TestCase):
def test_addition(self):
self.assertEqual(addition(2, 3), 5)
if __name__ == '__main__':
unittest.main()
# À exécuter avec la commande "python"Pourquoi automatiser les tests ?
Les tests automatiques offrent de nombreux avantages :
Et surtout, ils donnent confiance : quand tous les tests sont “verts”, on sait que le programme fonctionne toujours comme prévu.
Les tests automatiques ne remplacent pas la réflexion, mais ils en deviennent le prolongement : ils transforment le doute en méthode.
Apprendre à tester son code, c’est bien plus qu’une étape technique : c’est une façon de penser. Au début, on teste surtout pour corriger ses erreurs. Mais petit à petit, on comprend que tester, c’est aussi préparer l’avenir de son programme.
Un code testé, c’est un code qu’on peut modifier sans crainte. On peut ajouter une nouvelle fonctionnalité, changer une partie du programme, et vérifier aussitôt si tout fonctionne encore. Les tests deviennent alors comme un filet de sécurité : on peut avancer plus vite, tout en restant serein.
Tester régulièrement aide aussi à mieux comprendre ce qu’on écrit. Chaque test raconte une petite histoire : “si je fais ça, voilà ce que j’attends”. Et quand on lit ces tests plus tard, ou quand d’autres personnes découvrent notre travail, ils ou elles comprennent aussitôt comment le programme est censé se comporter.
Peu à peu, on réalise que tester n’est pas une corvée, mais une habitude utile. C’est une preuve de soin, de curiosité et de sérieux. Même les personnes qui codent depuis des années continuent à écrire des tests, simplement parce qu’elles savent que c’est ce qui fait la différence entre un code qui marche “par chance” et un code qui marche en toute confiance.
Tester son code, c’est un peu comme vérifier une recette avant de la servir : on s’assure que tout est bien mélangé, que le goût est bon, et qu’il n’y a pas d’ingrédient oublié.
Les tests permettent d’apprendre, de progresser et de comprendre ses erreurs. Ils rendent le code plus fiable, plus clair, et plus agréable à faire évoluer.
Au départ, cela peut sembler une étape en plus… mais très vite, on réalise que c’est un vrai gain de temps et de confiance. Un petit test aujourd’hui peut éviter de grandes erreurs demain.
Alors que ce soit à la main ou avec un outil automatique, gardons en tête cette idée simple : un bon programme, c’est un programme qu’on a pris le temps de vérifier !
Documentations officielles
Autres contenus sur Tainix
Other content to discover