Go Dilinde Sağlam ve Bakımı Kolay Testler Yazmak İçin Kapsamlı Bir Rehber

LydexCoding · 13 Ağu 2025

Yazılım geliştirmede kalitenin anahtarı şüphesiz testlerdir. Go (Golang) dili, test yazmayı dilin çekirdek felsefesine entegre ederek geliştiricilere güçlü ve basit bir test altyapısı sunar. Bu kapsamlı rehberde, Go'da etkili ve sürdürülebilir testler yazmak için farklı teknikleri, en iyi uygulamaları ve ipuçlarını detaylı bir şekilde inceleyeceğiz.

Neden Go'da Test Yazmalıyız?

Go'nun test altyapısı, uygulamanızın beklendiği gibi çalıştığından emin olmanızı sağlar, hataları erken aşamada yakalar ve kodunuzun gelecekteki değişikliklere karşı dayanıklılığını artırır. Hızlı derleme süreleri ve yerleşik test araçları sayesinde, Go'da test yazmak keyifli ve verimli bir süreçtir.

Temel Go Test Yapısı

Go'da testler, genellikle test edilecek dosya ile aynı dizinde `_test.go` uzantılı dosyalarda bulunur. Örneğin, `hesap.go` dosyasındaki fonksiyonları test etmek için `hesap_test.go` adında bir dosya oluşturursunuz. Test fonksiyonları `Test` önekiyle başlar ve `*testing.T` parametresi alır:

Kod:

package hesap

import "testing"

func Topla(a, b int) int {
    return a + b
}

func TestTopla(t *testing.T) {
    sonuc := Topla(2, 3)
    beklenen := 5
    if sonuc != beklenen {
        t.Errorf("Topla(2, 3) = %d; beklenen %d", sonuc, beklenen)
    }
}

Testleri çalıştırmak için projenizin kök dizininde veya test dosyasının bulunduğu dizinde `go test` komutunu kullanmanız yeterlidir. Daha detaylı çıktı almak için `-v` (verbose) bayrağını kullanabilirsiniz: `go test -v`.

Birincil Test Türleri ve Teknikleri

1. Birim Testleri (Unit Tests)

Birim testleri, kodunuzun en küçük, izole edilebilir parçalarını (fonksiyonlar, metotlar) test etmeye odaklanır. Go'da birim testleri yazmak oldukça basittir. En yaygın ve etkili yöntemlerden biri Tablo Odaklı Testlerdir (Table-Driven Tests). Bu yöntem, farklı giriş/çıkış senaryolarını tek bir veri yapısında tanımlayarak test kodunuzu daha okunabilir ve bakımı kolay hale getirir.

Örnek bir tablo odaklı test:

Kod:

package hesap

import "testing"

func Cikar(a, b int) int {
    return a - b
}

func TestCikar(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"pozitif sayılar", 5, 2, 3},
        {"negatif sayılar", -5, -2, -3},
        {"sıfır ve pozitif", 10, 0, 10},
        {"sıfır ve negatif", 0, 7, -7},
        {"sıfır ve sıfır", 0, 0, 0},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            if got := Cikar(tt.a, tt.b); got != tt.expected {
                t.Errorf("Cikar(%d, %d) = %d; beklenen %d", tt.a, tt.b, got, tt.expected)
            }
        })
    }
}

Bu yaklaşım, test senaryolarınızı kolayca genişletmenize olanak tanır ve her senaryoyu bağımsız olarak çalıştırmak için `t.Run` kullanır.

2. Entegrasyon Testleri (Integration Tests)

Entegrasyon testleri, uygulamanızın farklı modüllerinin veya harici servislerle (veritabanları, API'ler, dosya sistemleri) etkileşimini test eder. Go'da entegrasyon testleri yazarken, gerçek servisleri taklit etmek için mocklama ve stublama teknikleri sıkça kullanılır. Ancak bazı durumlarda, gerçek servislere karşı test yapmak daha uygun olabilir, özellikle de servisin kendisinin doğru çalıştığını doğrulamak istediğinizde.

Web uygulamaları için `net/http/httptest` paketi oldukça kullanışlıdır. Bu paket, gerçek bir HTTP sunucusu çalıştırmadan HTTP isteklerini test etmenizi sağlar:

Kod:

package main

import (
    "fmt"
    "net/http"
    "net/http/httptest"
    "testing"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Merhaba, Dünya!")
}

func TestHelloHandler(t *testing.T) {
    req := httptest.NewRequest("GET", "/hello", nil)
    rr := httptest.NewRecorder()

    handler := http.HandlerFunc(helloHandler)
    handler.ServeHTTP(rr, req)

    if status := rr.Code; status != http.StatusOK {
        t.Errorf("handler %v durum kodu döndürdü, beklenen %v", status, http.StatusOK)
    }

    expected := "Merhaba, Dünya!"
    if rr.Body.String() != expected {
        t.Errorf("handler yanlış gövde döndürdü: got %v want %v",
            rr.Body.String(), expected)
    }
}

Veritabanı gibi harici bağımlılıkları içeren entegrasyon testleri için genellikle test veritabanları veya Docker kapsayıcıları kullanılır. Bu, testlerin izole ve tekrarlanabilir olmasını sağlar.

Martin Fowler'ın test piramidi prensibini hatırlamakta fayda var: En altta çok sayıda hızlı birim testi, ortada daha az entegrasyon testi ve en üstte çok az uçtan uca (end-to-end) test bulunmalıdır. Bu denge, testlerin hızlı çalışmasını ve kapsamlı olmasını sağlar.

3. Fuzz Testleri (Fuzzing)

Go 1.18 ile birlikte yerleşik fuzzing desteği geldi. Fuzz testleri, programınıza rastgele, beklenmedik veya geçersiz girişler sağlayarak, potansiyel güvenlik açıkları veya çöküşler gibi nadir bulunan hataları ortaya çıkarmayı amaçlar. Fuzz testleri, `Fuzz` önekiyle başlar ve `*testing.F` parametresi alır:

Kod:

package main

import (
    "bytes"
    "testing"
)

func Reverse(s string) string {
    r := []rune(s)
    for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
        r[i], r[j] = r[j], r[i]
    }
    return string(r)
}

func FuzzReverse(f *testing.F) {
    testcases := []string{"Merhaba", "dünya", ""}
    for _, tc := range testcases {
        f.Add(tc) // Seed corpus
    }

    f.Fuzz(func(t *testing.T, orig string) {
        rev := Reverse(orig)
        doubleRev := Reverse(rev)
        if orig != doubleRev {
            t.Errorf("Before: %q, after: %q", orig, doubleRev)
        }
        if bytes.ContainsRune([]byte(rev), '\x00') {
            t.Errorf("Reverse produced a null byte in %q", rev)
        }
    })
}

`go test -fuzz=.` komutu ile fuzz testlerini başlatabilirsiniz. Bu, kodunuzun beklenmedik girdilere nasıl tepki verdiğini anlamak için güçlü bir yöntemdir.

4. Performans Testleri (Benchmarks)

Go, kodunuzun performansını ölçmek için yerleşik benchmark desteği sunar. Benchmark fonksiyonları `Benchmark` önekiyle başlar ve `*testing.B` parametresi alır. Bu fonksiyonlar, kodu defalarca çalıştırarak ortalama çalışma süresini ve bellek tahsisini ölçer.

Kod:

package main

import (
    "strings"
    "testing"
)

func BenchmarkConcatString(b *testing.B) {
    s := ""
    for i := 0; i < b.N; i++ {
        s += "a"
    }
}

func BenchmarkBuilderString(b *testing.B) {
    var sb strings.Builder
    for i := 0; i < b.N; i++ {
        sb.WriteString("a")
    }
    _ = sb.String()
}

Benchmarkları çalıştırmak için `go test -bench=.` veya belirli bir benchmark için `go test -bench=BenchmarkConcatString` komutunu kullanın. Sonuçlar, fonksiyonlarınızı optimize etmek için değerli bilgiler sağlar.

5. Eşzamanlılık Testleri (Concurrency Tests)

Go'nun eşzamanlılık modelini (goroutine'ler ve kanallar) kullanırken, yarış koşulları (race conditions) ve kilitlenmeler (deadlocks) gibi hatalar ortaya çıkabilir. Go'nun `race detector`'ı bu tür sorunları bulmakta oldukça etkilidir. Testlerinizi `go test -race` komutuyla çalıştırarak eşzamanlılık sorunlarını tespit edebilirsiniz.

Kod:

package main

import (
    "sync"
    "testing"
    "time"
)

func IncrementCounter(wg *sync.WaitGroup, mu *sync.Mutex, counter *int) {
    defer wg.Done()
    mu.Lock()
    *counter++
    mu.Unlock()
}

func TestConcurrentIncrement(t *testing.T) {
    var wg sync.WaitGroup
    var mu sync.Mutex
    counter := 0

    numGoroutines := 100
    wg.Add(numGoroutines)

    for i := 0; i < numGoroutines; i++ {
        go IncrementCounter(&wg, &mu, &counter)
    }
    wg.Wait()

    expected := numGoroutines
    if counter != expected {
        t.Errorf("Beklenen sayaç %d, ancak %d bulundu", expected, counter)
    }
    time.Sleep(10 * time.Millisecond) // Give race detector time
}

`time.Sleep` eklenmesi, bazı yarış koşullarının daha görünür hale gelmesine yardımcı olabilir, ancak asıl araç `go test -race`'tir.

6. Hata Testleri (Error Testing)

Kodunuzun beklenen hataları doğru bir şekilde ele aldığından emin olmak da testlerin önemli bir parçasıdır. Özellikle dışarıdan gelen girdilerin hatalı olabileceği durumları veya bir servisin kullanılamadığı senaryoları test etmek kritik öneme sahiptir.

Kod:

package main

import (
    "errors"
    "testing"
)

var ErrNegative = errors.New("negatif değer kabul edilemez")

func ProcessValue(val int) (int, error) {
    if val < 0 {
        return 0, ErrNegative
    }
    return val * 2, nil
}

func TestProcessValueError(t *testing.T) {
    _, err := ProcessValue(-5)
    if err == nil {
        t.Error("Hata bekliyorduk ama hata almadık")
    }

    if !errors.Is(err, ErrNegative) {
        t.Errorf("Yanlış hata türü: beklenen %v, alınan %v", ErrNegative, err)
    }

    if err.Error() != ErrNegative.Error() {
        t.Errorf("Yanlış hata mesajı: beklenen '%v', alınan '%v'", ErrNegative.Error(), err.Error())
    }
}

func TestProcessValueSuccess(t *testing.T) {
    result, err := ProcessValue(10)
    if err != nil {
        t.Errorf("Hata almamamız gerekiyordu: %v", err)
    }
    if result != 20 {
        t.Errorf("Beklenen sonuç 20, alınan %d", result)
    }
}

Test Kapsamı (Test Coverage)

Test kapsamı, kodunuzun yüzde kaçının testler tarafından çalıştırıldığını gösteren bir ölçüttür. Go, bu bilgiyi toplamak için yerleşik araçlara sahiptir. `go test -cover` komutunu kullanarak test kapsamınızı görüntüleyebilirsiniz. Daha görsel bir çıktı için `go test -coverprofile=coverage.out` ve ardından `go tool cover -html=coverage.out` komutlarını kullanabilirsiniz. Bu, bir web tarayıcısında, hangi kod satırlarının test edildiğini veya edilmediğini gösteren renklendirilmiş bir HTML raporu açacaktır.

Go'da Test Yazarken En İyi Uygulamalar

Testleri Küçük ve İzole Tutun: Her test, tek bir belirli senaryoyu test etmeli ve diğer testlerden bağımsız olmalıdır. Bu, testlerin hata ayıklamasını kolaylaştırır ve daha hızlı çalışmasını sağlar.
Okunabilir ve Anlaşılır Testler Yazın: Test fonksiyonu isimleri, neyin test edildiğini açıkça belirtmelidir (örneğin, `TestHesap_Topla_PozitifSayilar`). Test içindeki mantık da basit ve takip edilebilir olmalıdır.
Her Test Senaryosunun Belirli Bir Amacı Olsun: Bir test, yalnızca bir şeyi kanıtlamalıdır. Çoklu doğrulama adımları içeren testler, neyin yanlış gittiğini anlamayı zorlaştırabilir.
Hata Mesajlarını Açıklayıcı Yapın: `t.Errorf` veya `t.Fatalf` kullanırken, hata durumunda ne beklediğinizi ve ne bulduğunuzu açıkça belirtin. Bu, bir test başarısız olduğunda sorunun nedenini hızlıca bulmaya yardımcı olur.
Dış Bağımlılıklardan Kaçının veya Mocklayın: Testleriniz mümkün olduğunca dış sistemlere (veritabanları, harici API'ler) bağımlı olmamalıdır. Eğer bağımlılık varsa, bunları mock veya stub kullanarak izole etmeye çalışın. Gerçek entegrasyon testleri için ayrı bir strateji belirleyin.
Testleri Düzenli Olarak Çalıştırın: Kod tabanınızda her değişiklik yaptığınızda testleri çalıştırmak, regresyonları (önceden çalışan özelliklerin bozulması) önlemeye yardımcı olur. CI/CD (Sürekli Entegrasyon/Sürekli Dağıtım) boru hattınızın bir parçası olmalıdır.
Test Yardımcıları Kullanın: `testify` gibi üçüncü taraf kütüphaneler veya kendi yazdığınız yardımcı fonksiyonlar (örneğin, bir `assert` fonksiyonu) test kodunuzu daha kısa ve daha ifade edici hale getirebilir. Ancak Go'nun yerleşik `testing` paketinin basitliği genellikle çoğu senaryo için yeterlidir.
Setup/Teardown için `TestMain` veya Alt Testler Kullanın: Eğer testlerinizden önce veya sonra belirli bir kurulum/temizleme işlemine ihtiyacınız varsa, `TestMain` fonksiyonunu veya `t.Run` ile alt testlerin `setUp` ve `tearDown` desenini kullanabilirsiniz. `TestMain` fonksiyonu, tüm testler çalıştırılmadan önce ve sonra kod çalıştırmanıza izin verir.

Sonuç

Go'nun sağlam ve basit test altyapısı, yüksek kaliteli ve güvenilir yazılımlar geliştirmek için harika bir temel sunar. Birim testlerinden performans testlerine, eşzamanlılık sorunlarını tespit etmeye kadar birçok farklı senaryoyu kolayca test edebilirsiniz. En iyi uygulamaları benimseyerek ve sürekli test ederek, Go projelerinizin uzun ömürlü ve bakımı kolay olmasını sağlayabilirsiniz. Unutmayın, iyi yazılmış testler sadece hataları bulmakla kalmaz, aynı zamanda kodunuz için canlı, güncel bir dokümantasyon görevi de görür.