110 lines
3.6 KiB
Go
110 lines
3.6 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// 🧪 GO 09 TESTSUITE: Goroutines & sync.WaitGroup
|
|
|
|
func assert(condition bool, msg string) {
|
|
if !condition {
|
|
panic("❌ Test fehlgeschlagen: " + msg)
|
|
}
|
|
}
|
|
|
|
func assertEquals[T comparable](actual, expected T, msg string) {
|
|
if actual != expected {
|
|
panic(fmt.Sprintf("❌ Test fehlgeschlagen: %s (Erwartet: '%v', Erhalten: '%v')", msg, expected, actual))
|
|
}
|
|
}
|
|
|
|
// TEST: TestServerMetricStruct - Überprüft Struct-Definition
|
|
func TestServerMetricStruct() {
|
|
fmt.Println("=== RUN TestServerMetricStruct")
|
|
m := ServerMetric{
|
|
ServerID: "srv-test-1",
|
|
LatencyMs: 25,
|
|
Status: "ONLINE",
|
|
Timestamp: time.Now(),
|
|
}
|
|
assertEquals(m.ServerID, "srv-test-1", "ServerID muss korrekt gesetzt sein")
|
|
assertEquals(m.LatencyMs, 25, "LatencyMs muss 25 sein")
|
|
assertEquals(m.Status, "ONLINE", "Status muss ONLINE sein")
|
|
fmt.Println("--- PASS: TestServerMetricStruct")
|
|
}
|
|
|
|
// TEST: TestCheckServerWorker - Prüft die CheckServer Worker-Funktion
|
|
func TestCheckServerWorker() {
|
|
fmt.Println("=== RUN TestCheckServerWorker")
|
|
var wg sync.WaitGroup
|
|
out := make(chan ServerMetric, 3)
|
|
|
|
wg.Add(3)
|
|
go CheckServer("srv-fast", &wg, out)
|
|
go CheckServer("slow-db", &wg, out)
|
|
go CheckServer("offline-gateway", &wg, out)
|
|
|
|
wg.Wait()
|
|
close(out)
|
|
|
|
results := make(map[string]ServerMetric)
|
|
for m := range out {
|
|
results[m.ServerID] = m
|
|
}
|
|
|
|
assertEquals(len(results), 3, "Alle 3 Server-Checks müssen im Channel ankommen")
|
|
assertEquals(results["srv-fast"].Status, "ONLINE", "srv-fast sollte ONLINE sein")
|
|
assertEquals(results["slow-db"].Status, "DEGRADED", "slow-db sollte DEGRADED sein")
|
|
assertEquals(results["offline-gateway"].Status, "OFFLINE", "offline-gateway sollte OFFLINE sein")
|
|
fmt.Println("--- PASS: TestCheckServerWorker")
|
|
}
|
|
|
|
// TEST: TestBatchHealthCheckConcurrency - Prüft Batch-Health-Check und Sortierung
|
|
func TestBatchHealthCheckConcurrency() {
|
|
fmt.Println("=== RUN TestBatchHealthCheckConcurrency")
|
|
servers := []string{"srv-gamma", "slow-beta", "srv-alpha", "offline-delta"}
|
|
start := time.Now()
|
|
metrics := BatchHealthCheck(servers)
|
|
duration := time.Since(start)
|
|
|
|
assertEquals(len(metrics), 4, "BatchHealthCheck sollte 4 Metriken liefern")
|
|
// Prüfen auf aufsteigende Sortierung nach ServerID
|
|
assertEquals(metrics[0].ServerID, "offline-delta", "Erstes Element muss sortiert sein")
|
|
assertEquals(metrics[1].ServerID, "slow-beta", "Zweites Element muss sortiert sein")
|
|
assertEquals(metrics[2].ServerID, "srv-alpha", "Drittes Element muss sortiert sein")
|
|
assertEquals(metrics[3].ServerID, "srv-gamma", "Viertes Element muss sortiert sein")
|
|
|
|
assert(duration < 2*time.Second, "Parallele Ausführung darf nicht sequentiell blockieren")
|
|
fmt.Println("--- PASS: TestBatchHealthCheckConcurrency")
|
|
}
|
|
|
|
// TEST: TestParallelTaskRunnerOrdering - Prüft Task-Runner mit Index-Erhalt
|
|
func TestParallelTaskRunnerOrdering() {
|
|
fmt.Println("=== RUN TestParallelTaskRunnerOrdering")
|
|
tasks := []func() string{
|
|
func() string { return "Result-0" },
|
|
func() string { return "Result-1" },
|
|
func() string { return "Result-2" },
|
|
func() string { return "Result-3" },
|
|
}
|
|
|
|
results := ParallelTaskRunner(tasks)
|
|
assertEquals(len(results), 4, "ParallelTaskRunner muss 4 Ergebnisse zurückgeben")
|
|
for i := 0; i < 4; i++ {
|
|
expected := fmt.Sprintf("Result-%d", i)
|
|
assertEquals(results[i], expected, fmt.Sprintf("Index %d muss übereinstimmen", i))
|
|
}
|
|
fmt.Println("--- PASS: TestParallelTaskRunnerOrdering")
|
|
}
|
|
|
|
func main() {
|
|
fmt.Println("🧪 Starte Go 09 Testsuite...")
|
|
TestServerMetricStruct()
|
|
TestCheckServerWorker()
|
|
TestBatchHealthCheckConcurrency()
|
|
TestParallelTaskRunnerOrdering()
|
|
fmt.Println("\n✅ Alle Tests in Go 09 erfolgreich bestanden!")
|
|
}
|