Learn Rust Coding · Lekcja

Testy jednostkowe

Atrybut test

Testy jednostkowe to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Testowanie w Rust

Rust ma wbudowane testowanie — nie jest potrzebny zewnętrzny framework. Testy są zwykłymi funkcjami oznaczonymi za pomocą #[test] i uruchamianymi przez cargo test.

Pierwszy test

Funkcja testowa nie przyjmuje argumentów i korzysta z asercji. Jeśli zakończy działanie normalnie, test przechodzi; jeśli wywoła panikę, test kończy się niepowodzeniem.

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));
}

Makra asercji

Standardowe asercje to:

assert!(cond) — kończy się niepowodzeniem, gdy warunek jest fałszywy
assert_eq!(a, b) — kończy się niepowodzeniem, gdy wartości nie są równe
assert_ne!(a, b) — kończy się niepowodzeniem, gdy wartości są równe

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

Moduł tests

Zgodnie z przyjętą konwencją testy jednostkowe umieszcza się w module oznaczonym za pomocą #[cfg(test)], aby były kompilowane tylko podczas testowania.

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::*

Ponieważ moduł testów jest zagnieżdżony, use super::* wprowadza do zakresu elementy modułu nadrzędnego (funkcje, które chcesz testować).

Uruchamianie testów

cargo test kompiluje i uruchamia każdy test. Informuje, ile testów zakończyło się powodzeniem, niepowodzeniem lub zostało pominiętych.

cargo test

Testowanie paniki

Użyj #[should_panic], aby sprawdzić, czy funkcja wywołuje panikę w określonych warunkach.

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() {}

Testy zwracające Result

Test może zwracać Result, co pozwala używać operatora ?. Zwrócenie wartości Err powoduje niepowodzenie testu.

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() {}

Pomijanie testów

Testy długotrwałe lub zależne od środowiska oznacz za pomocą #[ignore]. Uruchom je jawnie poleceniem cargo test -- --ignored.

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

fn main() {}

Przydatne opcje testów

Przydatne opcje podczas uruchamiania testów:

cargo test name — uruchamia testy pasujące do nazwy
cargo test -- --nocapture — wyświetla dane wyjściowe println
cargo test -- --test-threads=1 — uruchamia testy sekwencyjnie

Testowanie funkcji prywatnych

Ponieważ moduł testów jest zagnieżdżony w tym samym pliku, może uzyskiwać dostęp do funkcji prywatnych — czego nie mogą robić testy integracyjne. To kluczowa zaleta testów jednostkowych.

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));
}

Szybkie sprawdzenie

Jaki atrybut oznacza funkcję jako test, który Cargo powinno uruchomić?

Podsumowanie

Dowiedziałeś się o wbudowanym testowaniu w Rust:

#[test] oznacza funkcje testowe
Asercje: assert!, assert_eq!, assert_ne!
Testy znajdują się w module #[cfg(test)] z użyciem use super::*
Testy z #[should_panic] i zwracające Result obsługują błędy
cargo test uruchamia wszystko

Często zadawane pytania

Czy lekcja „Testy jednostkowe” jest bezpłatna?

Tak — pełny tekst „Testy jednostkowe” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Co nauczysz się w „Testy jednostkowe”?

Atrybut test Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Testy jednostkowe”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Learn Rust Coding