Jak testy a metodologie TDD ovlivňují organizaci…

Testy a TDD mají významný vliv na organizaci kódu:

Modularita a rozdělení: Psaní testů před nebo během vývoje podporuje tvorbu malých, snadno testovatelných funkcí a komponent, což zlepšuje modularitu a snižuje propojenost kódu.
Čistota a srozumitelnost: Testy slouží jako živá dokumentace a příklady použití kódu. Je obtížné psát testy pro špatně navržený, zmatený (spagetti) kód. To podporuje psaní čistšího a srozumitelnějšího kódu.
Vylepšení API: Proces psaní testů nutí k použití API vyvíjených modulů zvenčí. To pomáhá včas odhalit nepohodlné nebo nelogické části API a zlepšit je před jejich širokým použitím.
Podpora refaktoringu: Rozsáhlá sada testů dává důvěru při refaktoringu. Testy rychle odhalí regresi, což umožňuje bezpečně měnit vnitřní strukturu kódu bez narušení jeho vnějšího chování.
Rychlé odhalení chyb: Testy pomáhají odhalit chyby v raných fázích vývoje, což výrazně snižuje náklady na jejich opravu ve srovnání s odhalením v produkci.

Příklad organizace kódu inspirované TDD (v Golangu):

package calculator // Balíček pro konkrétní funkčnost

import "errors" // Závislosti

// Add sčítá dvě celá čísla.
func Add(a, b int) int {
	return a + b // Jednoduchá logika
}

// Divide dělí num den. Vrací chybu, pokud den je 0.
func Divide(num, den int) (int, error) {
	if den == 0 {
		// Explicitní ošetření hraničních případů, snadno testovatelné
		return 0, errors.New("dělení nulou není povoleno")
	}
	return num / den, nil
}

Příslušné testy:

package calculator // Ve stejném balíčku, ale v samostatném souboru (_test.go)

import (
	"testing"
)

// TestAdd ověřuje funkci Add.
func TestAdd(t *testing.T) {
	// Testovací případy pro různé vstupy
	testCases := []struct {
		name   string
		a, b   int
		expected int
	}{
		{"Pozitivní čísla", 1, 2, 3},
		{"Negativní čísla", -1, -2, -3},
		{"Smíšená čísla", -1, 2, 1},
		{"Nula a pozitivní", 0, 5, 5},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) { // Použití t.Run pro strukturování
			result := Add(tc.a, tc.b) // Volání testované funkce
			if result != tc.expected {
				// Jasná chybová zpráva
				t.Errorf("Add(%d, %d): Očekáváno %d, získáno %d", tc.a, tc.b, tc.expected, result)
			}
		})
	}
}

// TestDivide ověřuje funkci Divide.
func TestDivide(t *testing.T) {
	testCases := []struct {
		name        string
		num, den    int
		expected int
		expectError bool
	}{
		{"Pozitivní dělení", 10, 2, 5, false},
		{"Negativní výsledek", 10, -2, -5, false},
		{"Dělení jedničkou", 7, 1, 7, false},
		{"Dělení nulou", 5, 0, 0, true}, // Případ chyby
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			result, err := Divide(tc.num, tc.den)

			if tc.expectError {
				if err == nil {
					// Kontrola očekávané chyby
					t.Errorf("Divide(%d, %d): Očekávaná chyba, ale nebyla", tc.num, tc.den)
				}
			} else {
				if err != nil {
					// Kontrola absence chyby
					t.Errorf("Divide(%d, %d): Nečekaná chyba: %v", tc.num, tc.den, err)
				}
				if result != tc.expected {
					// Kontrola výsledku
					t.Errorf("Divide(%d, %d): Očekáváno %d, získáno %d", tc.num, tc.den, tc.expected, result)
				}
			}
		})
	}
}

Tabulka ukazující vliv TDD na organizaci kódu:

Charakteristika kódu	Bez TDD / Slabé testy	S TDD / Silné testy
Modularita	Vysoká koheze, velké funkce	Nízká koheze, malé, čisté funkce
Přehlednost	Může být matoucí, nejasné závislosti	Přehlednější, jasné rozhraní
Refaktoring	Rizikové, vysoká pravděpodobnost chyb	Bezpečné, chyby se rychle odhalí
Detekce chyb	Pozdě, v integračních testech nebo v produkci	Brzy, v unit/integration testech
Dokumentace	Chybí nebo zastaralá	Testy jako živá, aktuální dokumentace
Kvalita API	Může být nepohodlné nebo nekonzistentní	Ergonomičtější a konzistentnější API

Celkově, TDD a aktivní používání testů nejen ověřují funkčnost, ale jsou také mocnými nástroji návrhu, které vedou k vytváření kvalitnější, udržovatelné a flexibilní architektury kódu.

Jak testy a metodologie TDD ovlivňují organizaci kódu?