Ako ovplyvňujú testy a metodológia TDD organizáciu…

Testy a TDD majú významný vplyv na organizáciu kódu:

Dekompozícia a modularita: Písanie testov pred alebo počas vývoja podporuje vytváranie malých, ľahko testovateľných funkcií a komponentov, čo zlepšuje modularitu a znižuje prepojenosť kódu.
Čistota a zrozumiteľnosť: Testy slúžia ako živá dokumentácia a príklady použitia kódu. Nie je ľahké napísať testy pre zle navrhnutý, zamotaný (spagetti) kód. To podnecuje písanie čistejšieho a zrozumiteľnejšieho kódu.
Zlepšenie API: Proces písania testov núti používať API vytváraných modulov zvonku. To pomáha odhaliť nepohodlné alebo nelogické časti API v ranom štádiu a zlepšiť ho pred jeho širokým používaním.
Podpora refaktorovania: Prítomnosť komplexného súboru testov dáva istotu pri refaktorovaní. Testy rýchlo odhaľujú regresie, umožňujú bezpečne meniť vnútornú štruktúru kódu bez narušenia jeho vonkajšieho správania.
Rýchle odhaľovanie chýb: Testy umožňujú odhaľovať chyby v raných fázach vývoja, čo výrazne znižuje náklady na ich opravu v porovnaní s odhalením v produkcii.

Príklad organizácie kódu inšpirovaný TDD (v Golang):

package calculator // Balík pre konkrétnu funkcionalitu

import "errors" // Závislosti

// Add sčíta dve celé čísla.
func Add(a, b int) int {
	return a + b // Jednoduchá logika
}

// Divide delí num na den. Vráti chybu, ak je den 0.
func Divide(num, den int) (int, error) {
	if den == 0 {
		// Jasná obsluha hraničných prípadov, ľahko testovateľná
		return 0, errors.New("delenie nulou je neprípustné")
	}
	return num / den, nil
}

Príslušné testy:

package calculator // Testy v tom istom balíku, ale v samostatnom súbore (_test.go)

import (
	"testing"
)

// TestAdd testuje funkciu Add.
func TestAdd(t *testing.T) {
	// Testovacie prípady pre rôzne vstupy
	testCases := []struct {
		name   string
		a, b   int
		expected int
	}{
		{"Pozitívne čísla", 1, 2, 3},
		{"Negatívne čísla", -1, -2, -3},
		{"Zmiešané čísla", -1, 2, 1},
		{"Nula a pozitívne", 0, 5, 5},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) { // Použitie t.Run na štruktúrovanie testov
			result := Add(tc.a, tc.b) // Volanie testovanej funkcie
			if result != tc.expected {
				// Jasná správa o chybe
				t.Errorf("Add(%d, %d): Očakávané %d, získané %d", tc.a, tc.b, tc.expected, result)
			}
		})
	}
}

// TestDivide testuje funkciu Divide.
func TestDivide(t *testing.T) {
	testCases := []struct {
		name        string
		num, den    int
		expected int
		expectError bool
	}{
		{"Pozitívne delenie", 10, 2, 5, false},
		{"Negatívny výsledok", 10, -2, -5, false},
		{"Delenie jedničkou", 7, 1, 7, false},
		{"Delenie nulou", 5, 0, 0, true}, // prípad pre chybu
	}

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

			ak tc.expectError {
				ak err == nil {
					// Kontrola očakávanej chyby
					t.Errorf("Divide(%d, %d): Očakávaná chyba, ale nebola", tc.num, tc.den)
				}
			} else {
				ak err != nil {
					// Kontrola, že chyba nebola očakávaná
					t.Errorf("Divide(%d, %d): Neočakávaná chyba: %v", tc.num, tc.den, err)
				}
				if result != tc.expected {
					// Kontrola výsledku pri úspešnom vykonaní
					t.Errorf("Divide(%d, %d): Očakávané %d, získané %d", tc.num, tc.den, tc.expected, result)
				}
			}
		})
	}
}

Tabuľka ukazujúca vplyv TDD na organizáciu kódu:

Charakteristika kódu	Bez TDD / Slabé testy	S TDD / Silné testy
Modularita	Vysoká prepojenosť, veľké funkcie	Nízka prepojenosť, malé, čisté funkcie
Zrozumiteľnosť	Môže byť zamotaný, nejasné závislosti	Viac zrozumiteľný, jasné rozhrania
Zmeniteľnosť (Refaktoring)	Rizikové, vysoká pravdepodobnosť chýb	Bezpečné, chyby rýchlo odhalené
Odhaľovanie chýb	Neskoro, v integračných testoch alebo v produkcii	Rano, v unit/integration testoch
Dokumentácia	Chýba alebo je zastaraná	Testy ako živá, aktuálna dokumentácia
Kvalita API	Môže byť nepohodlné/neposledovateľné	Viac ergonomické a následovateľné API

Na záver, TDD a aktívne používanie testov nielenže overujú funkčnosť, ale sú aj mocným nástrojom návrhu, ktorý podnecuje tvorbu kvalitnejšieho, udržateľnejšieho a flexibilnejšieho kódu.

Ako ovplyvňujú testy a metodológia TDD organizáciu kódu?