Learn Rust Coding · Leçon

Tests unitaires

Attribut test

Tests unitaires est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.

Tester en Rust

Rust intègre les tests — aucun framework externe n’est nécessaire. Les tests sont des fonctions ordinaires annotées avec #[test], exécutées par cargo test.

Votre premier test

Une fonction de test ne prend aucun argument et utilise des assertions. Si elle se termine normalement, le test réussit ; si elle déclenche une panique, il échoue.

fn add(a: i32, b: i32) -> i32 {
    a + b
}

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

fn main() {
    println!("{}", add(2, 3));
}

Macros d’assertion

Les assertions standard sont les suivantes :

assert!(cond) — échoue si la condition est fausse
assert_eq!(a, b) — échoue si les valeurs sont différentes
assert_ne!(a, b) — échoue si les valeurs sont égales

fn main() {
    let x = 4;
    assert!(x > 0);
    assert_eq!(x, 4);
    assert_ne!(x, 5);
    println!("All assertions passed");
}

Le module tests

Par convention, les tests unitaires se trouvent dans un module annoté avec #[cfg(test)], afin de n’être compilés que pendant les tests.

fn square(n: i32) -> i32 {
    n * n
}

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

    #[test]
    fn squares_correctly() {
        assert_eq!(square(5), 25);
    }
}

fn main() {
    println!("{}", square(5));
}

use super::*

Comme le module de test est imbriqué, use super::* place dans la portée les éléments du module parent, c’est-à-dire les fonctions que vous souhaitez tester.

Exécuter les tests

cargo test compile et exécute tous les tests. Il indique combien ont réussi, échoué ou été ignorés.

cargo test

Tester les paniques

Utilisez #[should_panic] pour vérifier qu’une fonction déclenche une panique dans certaines conditions.

fn checked_div(a: i32, b: i32) -> i32 {
    if b == 0 {
        panic!("division by zero");
    }
    a / b
}

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

    #[test]
    #[should_panic(expected = "division by zero")]
    fn panics_on_zero() {
        checked_div(10, 0);
    }
}

fn main() {}

Tests renvoyant un résultat

Un test peut renvoyer Result, ce qui vous permet d’utiliser l’opérateur ?. Renvoyer Err fait échouer le test.

fn parse(s: &str) -> Result<i32, std::num::ParseIntError> {
    s.parse::<i32>()
}

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

    #[test]
    fn parses_number() -> Result<(), std::num::ParseIntError> {
        let n = parse("42")?;
        assert_eq!(n, 42);
        Ok(())
    }
}

fn main() {}

Ignorer des tests

Marquez les tests lents ou dépendant de l’environnement avec #[ignore]. Exécutez-les explicitement avec cargo test -- --ignored.

#[test]
#[ignore]
fn expensive_test() {
    // long-running work
}

fn main() {}

Options utiles pour les tests

Options utiles lors de l’exécution des tests :

cargo test name — exécute les tests dont le nom correspond
cargo test -- --nocapture — affiche la sortie de println
cargo test -- --test-threads=1 — exécute les tests en série

Tester des fonctions privées

Comme le module de test est imbriqué dans le même fichier, il peut accéder aux fonctions privées — ce que les tests d’intégration ne peuvent pas faire. C’est un avantage essentiel des tests unitaires.

fn internal(n: i32) -> i32 {
    n + 1
}

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

    #[test]
    fn tests_private() {
        assert_eq!(internal(4), 5);
    }
}

fn main() {
    println!("{}", internal(4));
}

Vérification rapide

Quel attribut marque une fonction comme un test que Cargo doit exécuter ?

Récapitulatif

Vous avez découvert les tests intégrés de Rust :

#[test] marque les fonctions de test
Assertions : assert!, assert_eq!, assert_ne!
Les tests se trouvent dans un module #[cfg(test)] avec use super::*
#[should_panic] et les tests renvoyant Result gèrent les erreurs
cargo test exécute tout

Questions Fréquemment Posées

La leçon « Tests unitaires » est-elle gratuite ?

Oui — le texte complet de « Tests unitaires » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Tests unitaires » ?

Attribut test Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?

Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Tests unitaires » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?

Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Learn Rust Coding