Tests Rust pour débutants : guide pratique et premiers pas

Pourquoi tester en Rust est passionnant, pas effrayant ?

Quand on débute avec Rust, on a l'impression que le compilateur fait déjà tout le travail. Il vérifie la mémoire, gère les emprunts et vous évite de vous tirer une balle dans le pied. Mais même le compilateur le plus strict ne peut pas vérifier la logique de votre programme. C'est là que les tests entrent en jeu.

Beaucoup de débutants ont peur des tests. Ils pensent que c'est une perte de temps, qu'il faut écrire du code ennuyeux. En réalité, les tests sont votre filet de sécurité. Ils vous aident à trouver les bugs plus vite, à refactoriser en toute confiance et à dormir tranquille après une mise en production.

Dans cet article, nous allons voir par où commencer avec les tests en Rust, même si vous êtes novice. Pas de blabla — que de la pratique, des exemples concrets et des conseils utiles pour vos projets réels.

Ce qu'il faut savoir avant de commencer

Avant d'écrire des tests, assurez-vous d'avoir installé Rust. Si ce n'est pas le cas, ouvrez un terminal et exécutez :

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Tout ce dont nous avons besoin est déjà intégré dans l'écosystème. Pas besoin d'installer de frameworks supplémentaires. Rust propose un moteur de test intégré et puissant, qui se lance avec une seule commande.

Créons un nouveau projet pour nos expériences :

cargo new rust_test_guide\ncd rust_test_guide

Parfait ! Nous avons maintenant un projet vierge pour apprendre à écrire des tests.

Premier test : on découvre avec un exemple

Ouvrez le fichier src/lib.rs. Par défaut, il est vide, mais nous allons y ajouter une fonction simple et son test.

Écrivons une fonction qui vérifie si un nombre est pair :

pub fn is_even(num: i32) -> bool {\n    num % 2 == 0\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test]\n    fn test_is_even() {\n        assert_eq!(is_even(4), true);\n        assert_eq!(is_even(7), false);\n    }\n}

Décortiquons le code :

\n
• #[cfg(test)] — cet attribut indique au compilateur : « Compile ce module uniquement lors de l'exécution des tests ». Il ne sera pas inclus dans la version finale.
\n
• mod tests — nous créons un module pour les tests. C'est une pratique standard.
\n
• use super::*; — nous importons tout ce qui est déclaré au-dessus pour pouvoir utiliser notre fonction is_even.
\n
• #[test] — un marqueur qui transforme une fonction ordinaire en test.
\n
• assert_eq! — une macro qui vérifie l'égalité de deux valeurs. Si elles ne sont pas égales, le test échoue.
\n

Lancez le test avec la commande :

cargo test

Si tout est correct, vous verrez un affichage vert :

running 1 test\ntest tests::test_is_even ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

Félicitations, vous avez écrit votre premier test en Rust ! Voyons maintenant comment écrire des vérifications plus poussées.

Les macros essentielles pour les tests

Dans vos tests, vous utiliserez constamment trois macros. Retenez-les :

\n
• assert!(expression) — vérifie que l'expression est vraie. Si elle est fausse, le test échoue.
\n
• assert_eq!(left, right) — vérifie l'égalité de deux valeurs. Pratique pour comparer des résultats.
\n
• assert_ne!(left, right) — vérifie que les valeurs sont différentes.
\n

Exemple d'utilisation des trois macros :

pub fn add_two(x: i32) -> i32 {\n    x + 2\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test]\n    fn test_add_two() {\n        assert!(add_two(3) == 5);\n        assert_eq!(add_two(0), 2);\n        assert_ne!(add_two(10), 13);\n    }\n}

Notez que assert! prend une expression booléenne, tandis que