Testlere Neden Kendini Aşık Olmalısınız? Kod Kalitesini Artırmanın Yolu

Yazılım geliştirme kariyerimin ilk yıllarında test deyince aklıma sadece ekrana basılan değerler ve breakpoint’ler gelirdi. Dönüp baktığımda, o dönem ne kadar da naif bir yaklaşımla çalıştığımı görüyorum. Bugların ne kadarının o süreçte gözden kaçtığını bile düşünmek istemiyorum. Profesyonel hayatta geçen yıllar içinde test sürecimi kökten değiştiren deneyimler yaşadım. İlerleme kaydettikçe anladım ki, etkili testler kod yazıldıktan sonra değil, yazıldığı anda başlamalı.

Yazılım Testlerinde Sık Düşülen Tuzaklar

Başlangıçta yaptığım en temel hatalardan biri, testleri kodun son haliyle tamamlanmasını beklemekti. Özellikle ilk iş yerimde uyguladığım workflow şöyleydi: değişiklikleri uygula, belgele, entegre et, dağıtıma gönder ve ancak o aşamada testlere başlamak. Bu yaklaşım doğal olarak şunlara yol açıyordu:

• Hataların geç keşfedilmesi ve anında çözülememesi
• Hataların ancak bir sonraki sürümde giderilmesi
• Sürecin sürekli olarak duraksamalara uğraması

Aynı zamanda birçok geliştiricinin farkında olmadan yaptığı bir hataya düştüğümü de fark ettim: testleri, üretim kodunun birebir bir kopyası olarak yazmak. Yani fonksiyonu test etmek yerine, fonksiyonun nasıl çalıştığını test ediyordum. Bu da kodun iki kez yazılması anlamına geliyordu ve aslında hiçbir katma değeri yoktu.

Doğru Testin Temelinde Ne Var?

Testlerin sadece kodun çalışıp çalışmadığını kontrol etmekle kalmayıp, aynı zamanda doğru ürünü geliştirdiğimize dair güvence vermesi gerektiğini öğrendim. Bu ayrım iki temel kavramla özetlenebilir:

• Doğrulama (Verification): Ürünü doğru şekilde mi inşa ediyoruz?
• Geçerleme (Validation): Doğru ürünü mü inşa ediyoruz?

Basit bir örnekle açıklamak gerekirse: bir futbol sahasının standart ölçülere uygun inşa edilmesi doğrulama sürecini temsil eder. Ancak sahanın oyun için ne kadar uygun olduğu geçerleme sürecine girer. Sahada tüm teknik gereksinimler karşılanmış olsa bile, zemin eğimliyse ya da düzensizse oyun imkansız hale gelebilir.

Testten Korkmak Yerine Testi Benimsemek

Zamanla testlerin aslında bir öğrenme süreci olduğunu anladım. Korkularım azaldıkça, testlere olan bakış açım da değişti. Testler sayesinde kodun nasıl davranması gerektiğine dair net tanımlar oluşturabiliyordum. Anında gelen geribildirimler sayesinde de güvenle ilerleyebiliyordum. Ancak yaşadığım tek sorun, bu geribildirimlerin hep çok geç gelmesiydi. Bu sorunu aşmanın yolunu ararken Test Odaklı Geliştirme (TDD) metodolojisiyle tanıştım.

Test Odaklı Geliştirme (TDD) Nedir ve Nasıl Uygulanır?

TDD çoğunlukla yanlış anlaşılan bir yaklaşımdır. TDD aslında bir test tekniği değil, bir tasarım metodudur. Burada testler, tasarımın şekillenmesine yardımcı olan araçlar olarak kullanılır. TDD hem doğrulama hem de geçerleme amacıyla kullanılabilir.

TDD’nin temel döngüsü şu şekildedir:

1. Kırmızı (Red): Öncelikle beklenen davranışı tanımlayan bir test yazın. Bu test başlangıçta başarısız olacaktır.
2. Yeşil (Green): Ardından en basit şekilde çalışan bir implementasyon yazın. Testin başarılı olmasını sağlayacak kadar yeterli olmalıdır.
3. Refactor (Refactor): Son olarak kodu temizleyin ve iyileştirin. Artık testler sayesinde herhangi bir regresyon olup olmadığını anında görebilirsiniz.

Aşağıdaki örnekte, bir vektörün normalize edilmesi için kullanılan ters karekök fonksiyonunun testlerini TDD yaklaşımıyla nasıl yazabileceğimizi görebilirsiniz:

// Pozitiflik Testi
// Ters karekök fonksiyonunun tüm pozitif girdiler için pozitif sonuç vermesi gerekir
#[test]
fn always_positive() {
    for &x in &inputs {
        assert!(inverse_sqrt(x) > 0.0);
    }
}

// Monotonluk Testi
// Fonksiyonun girdiler arttıkça azalması gerekir
#[test]
fn monotony() {
    for i in 0..inputs.len() - 1 {
        assert!(inverse_sqrt(inputs[i]) > inverse_sqrt(inputs[i + 1]));
    }
}

// Çarpım Kuralı Testi
// inverse_sqrt(a * b) ≈ inverse_sqrt(a) * inverse_sqrt(b)
#[test]
fn product_rule() {
    for i in 0..inputs.len() - 1 {
        let a = inputs[i];
        let b = inputs[i + 1];
        let x1 = inverse_sqrt(a * b);
        let x2 = inverse_sqrt(a) * inverse_sqrt(b);
        assert!((x1 - x2).abs() < 0.25);
    }
}

// Bölüm Kuralı Testi
// inverse_sqrt(a / b) ≈ inverse_sqrt(a) / inverse_sqrt(b)
#[test]
fn division_rule() {
    for i in 0..inputs.len() - 1 {
        let a = inputs[i];
        let b = inputs[i + 1];
        let x1 = inverse_sqrt(a / b);
        let x2 = inverse_sqrt(a) / inverse_sqrt(b);
        assert!((x1 - x2).abs() < 2.5);
    }
}

// Geçerleme: Normalizasyon Uzunluğu
// Normalize edilmiş vektörün uzunluğu 1’e eşit olmalıdır
#[test]
fn normalization_length_is_one() {
    for &(x, y, z) in &vectors {
        let n = normalize(x, y, z);
        let len = (n.0 * n.0 + n.1 * n.1 + n.2 * n.2).sqrt();
        assert!((len - 1.0).abs() < 1e-6);
    }
}

Bu testler çalıştırıldığında alacağınız çıktı şöyle olacaktır:

running 5 tests
test tests::monotony ... ok
test tests::division_rule ... ok
test tests::always_positive ... ok
test tests::normalization_length_is_one ... ok
test tests::product_rule ... ok
test result: ok. 5 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Gördüğünüz gibi, TDD’nin en büyük avantajlarından biri, davranışı önceden tanımladıktan sonra anında geribildirim alabilmenizdir. Bu sayede implementasyonunuzu güvenle geliştirebilir ve gerektiğinde yeniden düzenleyebilirsiniz.

TDD’nin Getirdiği Diğer Faydalar

• Daha az hata: Hatalar erken aşamada tespit edilir ve çözülür.
• Daha temiz kod: Sürekli iyileştirme ve yeniden düzenleme sayesinde kod kalitesi artar.
• Daha iyi dokümantasyon: Testler, kodun nasıl kullanılacağına dair doğal bir dokümantasyon sağlar.
• Daha güvenilir dağıtımlar: Sürekli entegrasyon ve testler sayesinde üretime gönderilen kodlar daha güvenilir hale gelir.

Test odaklı geliştirme sadece bir teknik değil, bir zihniyet değişikliğidir. Başlangıçta zorlayıcı görünebilir, ancak alıştıkça yazılım geliştirme sürecini nasıl dönüştürdüğünü görmek mümkün. Unutmayın: iyi bir test ağı, sadece hatalardan korunmanızı sağlamaz, aynı zamanda daha iyi bir geliştirici olmanıza da yardımcı olur.