edgeguard-native/internal/keepalived/keepalived_test.go

package keepalived

import (
	"bytes"
	"strings"
	"testing"

	"git.netcell-it.de/projekte/edgeguard-native/internal/models"
)

func render(t *testing.T, v View) string {
	t.Helper()
	var buf bytes.Buffer
	if err := tpl.Execute(&buf, v); err != nil {
		t.Fatalf("template execute: %v", err)
	}
	return buf.String()
}

// testView repräsentiert den bevorzugten Node (PG-Primary, Prio 200):
// preempt_delay statt nopreempt (holt die VIP nach stabiler Erholung heim).
// Kein Node startet MASTER (sonst würde preempt_delay/nopreempt ignoriert).
func testView() View {
	return View{
		State: "BACKUP", Interface: "eth0", RouterID: 51, Priority: 200,
		PreemptDelay: preemptDelaySeconds,
		SrcIP:        "89.163.205.6", PeerIP: "89.163.205.8", AuthPass: "edgeguard",
		VIPs:        []VIPEntry{{Address: "89.163.205.100", Prefix: 24, Device: "eth0"}},
		HBInterface: "ens19", HBSrcIP: "169.254.0.1", HBPeerIP: "169.254.0.2", HBRouterID: 52,
		GWCheckIP: "89.163.205.1",
	}
}

// Bevorzugter Node: preempt_delay auf beiden Instanzen, KEIN nopreempt.
func TestTemplatePreemptDelayOnPreferred(t *testing.T) {
	out := render(t, testView())
	if n := strings.Count(out, "preempt_delay"); n != 2 {
		t.Fatalf("erwarte preempt_delay in VI_1 UND VI_HB (2×), gefunden: %d\n%s", n, out)
	}
	if strings.Contains(out, "nopreempt") {
		t.Fatalf("bevorzugter Node (Prio 200) darf KEIN nopreempt tragen:\n%s", out)
	}
	if strings.Contains(out, "state MASTER") {
		t.Fatalf("kein Node darf state MASTER starten:\n%s", out)
	}
	if c := strings.Count(out, "state BACKUP"); c != 2 {
		t.Fatalf("erwarte state BACKUP in beiden Instanzen, gefunden: %d", c)
	}
}

// Standby (Prio 100, PreemptDelay=0): nopreempt auf beiden Instanzen —
// reißt die VIP nie an sich (Split-Brain-Schutz).
func TestTemplateNopreemptOnStandby(t *testing.T) {
	v := testView()
	v.Priority = 100
	v.PreemptDelay = 0
	out := render(t, v)
	if n := strings.Count(out, "nopreempt"); n != 2 {
		t.Fatalf("Standby: erwarte nopreempt 2×, gefunden: %d\n%s", n, out)
	}
	if strings.Contains(out, "preempt_delay") {
		t.Fatalf("Standby darf KEIN preempt_delay tragen:\n%s", out)
	}
}

// GARP muss forciert + periodic aufgefrischt werden, sonst altert die
// VIP-MAC am Upstream-Switch und die Failover-IP wird unerreichbar.
func TestTemplateGARPRefresh(t *testing.T) {
	out := render(t, testView())
	for _, want := range []string{"vrrp_garp_master_refresh", "vrrp_garp_master_repeat"} {
		if !strings.Contains(out, want) {
			t.Fatalf("global_defs sollte %q enthalten:\n%s", want, out)
		}
	}
}

// advert_int 2 (statt 1): Master-Down ~6s — reißt nicht bei kurzen
// VM-/Heartbeat-Hiccups (Flapping-Schutz im virtualisierten Cluster).
func TestTemplateAdvertInt(t *testing.T) {
	out := render(t, testView())
	if strings.Contains(out, "advert_int 1\n") {
		t.Fatalf("advert_int sollte 2 sein (nicht 1):\n%s", out)
	}
	if c := strings.Count(out, "advert_int 2"); c != 2 {
		t.Fatalf("erwarte advert_int 2 in beiden Instanzen, gefunden: %d", c)
	}
}

// Track-Scripts dürfen KEIN weight haben: in einer vrrp_sync_group ignoriert
// keepalived gewichtete Scripts → Health-Checks wären wirkungslos. Ohne weight
// wirken sie als FAULT-Trigger.
func TestTemplateTrackScriptsUnweighted(t *testing.T) {
	out := render(t, testView())
	if strings.Contains(out, "weight") {
		t.Fatalf("Track-Scripts dürfen kein weight tragen (Sync-Group ignoriert sie sonst):\n%s", out)
	}
}

// gw-Check darf nicht zu zucken (fall 5, nicht fall 2) — ein kurzer Upstream-
// Blip soll keinen Failover erzwingen.
func TestTemplateGatewayCheckNotTwitchy(t *testing.T) {
	out := render(t, testView())
	if !strings.Contains(out, "fall 5") {
		t.Fatalf("chk_gateway sollte fall 5 nutzen:\n%s", out)
	}
}

// buildView: State immer BACKUP, Priorität aus pg_role.
func TestBuildViewStateAlwaysBackup(t *testing.T) {
	g := &generator{localID: "n1"}
	cs := &models.ClusterSettings{VRRPRouterID: 51}
	pub := "89.163.205.6"
	cases := []struct {
		pgRole, role string
		wantPrio     int
		wantPreempt  int // preempt_delay (bevorzugt) bzw. 0 (=nopreempt)
	}{
		{"primary", "primary", 200, preemptDelaySeconds},
		{"standby", "primary", 100, 0},
		{"", "primary", 200, preemptDelaySeconds},
		{"", "", 100, 0},
	}
	for _, c := range cases {
		local := &models.HANode{ID: "n1", PGRole: c.pgRole, Role: c.role, PublicIP: &pub}
		v := g.buildView(cs, nil, local, nil)
		if v.State != "BACKUP" {
			t.Errorf("pg_role=%q role=%q: State=%q, erwarte immer BACKUP", c.pgRole, c.role, v.State)
		}
		if v.Priority != c.wantPrio {
			t.Errorf("pg_role=%q role=%q: Priority=%d, erwarte %d", c.pgRole, c.role, v.Priority, c.wantPrio)
		}
		if v.PreemptDelay != c.wantPreempt {
			t.Errorf("pg_role=%q role=%q: PreemptDelay=%d, erwarte %d", c.pgRole, c.role, v.PreemptDelay, c.wantPreempt)
		}
	}
}