Test altyapısı

tests/ klasörüyle integration test eklersin.

Test altyapısı

Kütüphanenin davranışını testlerle güvenceye alırız. Testler aynı dosyada, yalnızca cargo test sırasında derlenen bir modülde durur:

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

    #[test]
    fn arama_yazara_gore_bulur() {
        let mut raf = Raf::new();
        raf.ekle(Kitap::new("Tutunamayanlar", "Oğuz Atay", 1972));
        assert_eq!(raf.ara("atay").len(), 1);
    }
}

#[cfg(test)] modülü normal derlemeye girmez; use super::.. üst modüldeki öğeleri kapsama alır.

Ne test edilmeli?

İyi testler, kullanıcının güvendiği sözleşmeyi denetler: kurucunun değerleri doğru saklaması, aramanın büyük/küçük harften bağımsız çalışması, bulunamayan sorgunun boş sonuç vermesi. Her test tek bir davranışı ve açıklayıcı bir adı olmalıdır:

#[test]
fn arama_buyuk_kucuk_harf_duyarsiz() { .. }

#[test]
fn bulunamayan_sorgu_bos_doner() {
    let raf: Raf<Kitap> = Raf::new();
    assert!(raf.ara("xyz").is_empty());
}

Uygulama Testler ve denetim

Önceki kütüphane koduna #[cfg(test)] mod tests ekle: ara("atay") için assert_eq! ile 2 sonuç ve ara("xyz") için boş sonuç denetleyen iki #[test] yaz. Alıştırma ortamı main'i çalıştırdığı için main'de de aynı iki denetimi assert! ile yap ve tüm denetimler geçti yazdır.

Örnek çözümü göster

mod kitaplik {
    pub struct Kitap {
        ad: String,
        yazar: String,
        yil: u16,
    }

    impl Kitap {
        pub fn new(ad: &str, yazar: &str, yil: u16) -> Self {
            Self {
                ad: ad.to_string(),
                yazar: yazar.to_string(),
                yil,
            }
        }
        pub fn ad(&self) -> &str {
            &self.ad
        }
        pub fn yil(&self) -> u16 {
            self.yil
        }
    }

    pub struct Raf<T> {
        ogeler: Vec<T>,
    }

    impl<T> Raf<T> {
        pub fn new() -> Self {
            Self { ogeler: Vec::new() }
        }
        pub fn ekle(&mut self, x: T) {
            self.ogeler.push(x);
        }
        pub fn len(&self) -> usize {
            self.ogeler.len()
        }
    }

    pub trait Aranabilir {
        fn eslesir(&self, sorgu: &str) -> bool;
    }

    impl Aranabilir for Kitap {
        fn eslesir(&self, sorgu: &str) -> bool {
            let s = sorgu.to_lowercase();
            self.ad.to_lowercase().contains(&s) || self.yazar.to_lowercase().contains(&s)
        }
    }

    impl<T: Aranabilir> Raf<T> {
        pub fn ara(&self, sorgu: &str) -> Vec<&T> {
            self.ogeler.iter().filter(|x| x.eslesir(sorgu)).collect()
        }
    }
}

use kitaplik::{Kitap, Raf};

fn ornek_raf() -> Raf<Kitap> {
    let mut raf = Raf::new();
    raf.ekle(Kitap::new("Tutunamayanlar", "Oğuz Atay", 1972));
    raf.ekle(Kitap::new("Tehlikeli Oyunlar", "Oğuz Atay", 1973));
    raf.ekle(Kitap::new("Kürk Mantolu Madonna", "Sabahattin Ali", 1943));
    raf
}

fn main() {
    let raf = ornek_raf();
    assert!(raf.ara("atay").len() == 2);
    assert!(raf.ara("xyz").is_empty());
    println!("tüm denetimler geçti");
}

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

    #[test]
    fn yazara_gore_bulur() {
        assert_eq!(ornek_raf().ara("atay").len(), 2);
    }

    #[test]
    fn bulunamayan_bos_doner() {
        assert!(ornek_raf().ara("xyz").is_empty());
    }
}

Kendini test et

<code>cargo test</code> bir test başarısız olduğunda ne yapar?
- Hemen durur
- Testi atlar
- Derleme hatası verir
- Diğer testleri çalıştırmaya devam eder ve sonunda başarısızları raporlar
Cevabı göster

Diğer testleri çalıştırmaya devam eder ve sonunda başarısızları raporlar — Her test kendi iş parçacığında çalışır; bir testin panic'i diğerlerini etkilemez.

Yalnızca testte derle

#[____]
mod tests {
    #[test]
    fn ornek() {}
}

Cevabı göster

#[cfg(test)]
mod tests {
    #[test]
    fn ornek() {}
}

Öğe ve görevi

#[cfg(test)]

Koşullu derleme
#[test]

Test fonksiyonu
assert_eq!(a, b)

Eşitlik denetimi
use super::*

Üst modülü kapsama alır

Sıradaki ders: Box<T>

Deneyiminizi Geliştiriyoruz

Çerez Tercihleri

Kesinlikle Gerekli Çerezler

Analitik Çerezler