Tests en Rust : frameworks et outils

Tests en Rust : frameworks et outils

Rust est un langage de programmation système qui accorde une grande importance à la fiabilité et à la sécurité. Le système de test intégré est l'une de ses caractéristiques clés, permettant d'écrire du code de qualité sans avoir à installer de frameworks tiers. Dans cet article, nous allons examiner en détail les principaux outils de test en Rust : des tests unitaires simples aux tests basés sur les propriétés et aux benchmarks.

Framework de test intégré

En Rust, les tests sont exécutés à l'aide de la commande cargo test. Les tests sont des fonctions ordinaires marquées par l'attribut #[test]. Le framework collecte automatiquement toutes ces fonctions dans votre projet et les exécute.

Tests unitaires

Les tests unitaires sont généralement placés dans le même fichier que le code testé, dans un module séparé tests. Cela permet de tester les fonctions privées.

// src/lib.rspub fn add(a: i32, b: i32) -> i32 {    a + b}

fn private_helper(x: i32) -> i32 {    x * 2}

#[cfg(test)]mod tests {    use super::*;

    #[test]    fn test_add() {        assert_eq!(add(2, 3), 5);    }

    #[test]    fn test_private_helper() {        assert_eq!(private_helper(5), 10);    }}

Exécution : cargo test

Tests d'intégration

Les tests d'intégration se trouvent dans le répertoire tests/ à la racine du projet. Chaque fichier de ce dossier est une crate séparée qui teste votre API publique.

// tests/integration_test.rsuse my_crate::add;

#[test]fn test_add_integration() {    assert_eq!(add(10, 20), 30);}

Macros pour les assertions

Rust fournit plusieurs macros intégrées pour écrire des assertions :

• assert!(expression) — panique si l'expression est fausse.
• assert_eq!(left, right) — vérifie l'égalité avec PartialEq.
• assert_ne!(left, right) — vérifie l'inégalité.
• debug_assert!() — fonctionne uniquement dans les builds de débogage.

#[test]fn test_with_assert() {    let result = some_function();    assert!(result.is_ok(), "Ok attendu, obtenu : {:?}", result);    assert_eq!(result.unwrap(), 42);}

Doctests

L'une des fonctionnalités les plus puissantes de Rust est la possibilité d'écrire des tests directement dans la documentation. Le code à l'intérieur des blocs /// ou //! est automatiquement compilé et exécuté comme un test.

/// Additionne deux nombres.////// # Exemples////// ```/// use my_crate::add;/// assert_eq!(add(1, 2), 3);/// ```pub fn add(a: i32, b: i32) -> i32 {    a + b}

Exécution : cargo test — les doctests sont exécutés avec les tests normaux.

Tests basés sur les propriétés avec proptest

La bibliothèque proptest (analogue à Hypothesis en Python ou QuickCheck en Haskell) permet de générer des données d'entrée aléatoires et de vérifier des invariants.

use proptest::prelude::*;

fn reverse_string(s: &str) -> String {    s.chars().rev().collect()}

proptest! {    #[test]    fn test_reverse_twice(s in ".*") {        let reversed = reverse_string(&s);        let double_reversed = reverse_string(&reversed);        assert_eq!(s, double_reversed);    }}

Installation : cargo add proptest

Benchmarks

Pour mesurer les performances en Rust, il existe des benchmarks stables (depuis Rust 1.78) via cargo bench et la crate criterion pour des scénarios plus complexes.

Benchmarks intégrés (nightly)

#![feature(test)]extern crate test;

#[bench]fn bench_add(b: &mut test::Bencher) {    b.iter(|| add(1, 2));}

Benchmarks avec criterion

Aussi dans la bibliothèque

Django : le framework web Python puissant et complet BeautifulSoup – Parsing HTML avec Python Files d'attente de tâches pour PHP : RabbitMQ, Gearman et PhpAmqpLib Travailler avec XML en Rust : parsing, création et sérialisation de données Client HTTP pour TypeScript : top bibliothèques pour le développement web