Netpulse_SasS/server/internal/store/ncm_rollback_plan_test.go

package store

import (
	"errors"
	"strings"
	"testing"
)

// Перевірки плану відкату.
//
// Перевіряється саме побудова команд, а не робота з базою: усе, що може
// зіпсувати вузол, вирішується в чистій функції від двох текстів, і
// саме її треба тримати під наглядом. Помилка тут не падає й не
// логується — вона просто виконується на живому залізі.

func ciscoProfile() ApplyProfile {
	return ApplyProfile{
		Supported: true,
		Enter:     []string{"configure terminal"},
		Exit:      []string{"end"},
		Commit:    "write memory",
		Negate:    "no ",
		BlockExit: "exit",
	}
}

func TestPlanAddsMissingLine(t *testing.T) {
	cur := "hostname sw1\nip domain-name example\n"
	tgt := "hostname sw1\nip domain-name example\nlogging host 10.0.0.1\n"

	plan, err := BuildRollbackPlan(cur, tgt, ciscoProfile())
	if err != nil {
		t.Fatalf("несподівана помилка: %v", err)
	}
	want := []string{"configure terminal", "logging host 10.0.0.1", "end"}
	assertCommands(t, plan.Commands, want)
	if plan.CommitCommand != "write memory" {
		t.Errorf("команда збереження: %q", plan.CommitCommand)
	}
}

// Зайвий рядок має піти з пристрою, а не лишитись поруч із потрібним.
// Це вся суть відкату: «залити старий конфіг» без прибирання нового
// дало б старий конфіг ПЛЮС те, від чого відкочувались.
func TestPlanNegatesExtraLine(t *testing.T) {
	cur := "hostname sw1\nvlan 200\nlogging host 10.0.0.1\n"
	tgt := "hostname sw1\nlogging host 10.0.0.1\n"

	plan, err := BuildRollbackPlan(cur, tgt, ciscoProfile())
	if err != nil {
		t.Fatalf("несподівана помилка: %v", err)
	}
	assertCommands(t, plan.Commands,
		[]string{"configure terminal", "no vlan 200", "end"})
	if plan.Removed != 1 || plan.Added != 0 {
		t.Errorf("облік змін: +%d −%d", plan.Added, plan.Removed)
	}
}

// Рядок усередині інтерфейсу без назви інтерфейсу — це рядок, поданий у
// глобальний режим. Найдорожча помилка заливки, бо вона не падає.
func TestPlanRestoresParentContext(t *testing.T) {
	cur := "interface Gi0/1\n description uplink\n ip address 10.0.0.1 255.255.255.0\n"
	tgt := "interface Gi0/1\n description uplink\n ip address 10.0.0.2 255.255.255.0\n"

	plan, err := BuildRollbackPlan(cur, tgt, ciscoProfile())
	if err != nil {
		t.Fatalf("несподівана помилка: %v", err)
	}
	assertCommands(t, plan.Commands, []string{
		"configure terminal",
		"interface Gi0/1",
		"no ip address 10.0.0.1 255.255.255.0",
		"ip address 10.0.0.2 255.255.255.0",
		"exit",
		"end",
	})
}

// Прибирання йде ПЕРЕД додаванням у межах одного блока: частина
// платформ відкидає новий рядок як конфлікт зі старим, і тоді наступне
// заперечення прибрало б уже обидва.
func TestPlanRemovesBeforeAdds(t *testing.T) {
	cur := "snmp-server community old RO\n"
	tgt := "snmp-server community new RO\n"

	plan, err := BuildRollbackPlan(cur, tgt, ciscoProfile())
	if err != nil {
		t.Fatalf("несподівана помилка: %v", err)
	}
	iNo := indexOf(plan.Commands, "no snmp-server community old RO")
	iAdd := indexOf(plan.Commands, "snmp-server community new RO")
	if iNo < 0 || iAdd < 0 {
		t.Fatalf("у плані бракує команд: %v", plan.Commands)
	}
	if iNo > iAdd {
		t.Errorf("заперечення стоїть після додавання: %v", plan.Commands)
	}
}

// Родина без заперечення (D-Link) не має отримувати вигаданих команд:
// зайве йде людині переліком, а не механічно вигаданим `no`.
func TestPlanWithoutNegateGivesManualList(t *testing.T) {
	prof := ApplyProfile{
		Supported: true,
		Commit:    "save",
		BlockExit: "",
	}
	cur := "create vlan v10 tag 10\nconfig ports 1-4 speed auto\n"
	tgt := "config ports 1-4 speed auto\nconfig ports 5 speed 100_full\n"

	plan, err := BuildRollbackPlan(cur, tgt, prof)
	if err != nil {
		t.Fatalf("несподівана помилка: %v", err)
	}
	if len(plan.Manual) != 1 || plan.Manual[0] != "create vlan v10 tag 10" {
		t.Errorf("перелік «прибрати вручну»: %v", plan.Manual)
	}
	for _, c := range plan.Commands {
		if strings.HasPrefix(c, "no ") {
			t.Errorf("вигадане заперечення в плані: %q", c)
		}
	}
	assertCommands(t, plan.Commands, []string{"config ports 5 speed 100_full"})
}

// Коментарі й рядки під scrub не є командами: заливати шапку конфігу
// безглуздо, а в різниці вона створювала б зміну на кожному зборі — і
// контрольна перевірка після відкату завжди показувала б розбіжність.
func TestPlanSkipsCommentsAndScrub(t *testing.T) {
	prof := ciscoProfile()
	prof.ScrubPatterns = []string{`^ntp clock-period`}

	cur := "! згенеровано 12.03\nhostname sw1\nntp clock-period 17179869\n"
	tgt := "! згенеровано 14.03\nhostname sw2\nntp clock-period 17179999\n"

	plan, err := BuildRollbackPlan(cur, tgt, prof)
	if err != nil {
		t.Fatalf("несподівана помилка: %v", err)
	}
	assertCommands(t, plan.Commands,
		[]string{"configure terminal", "no hostname sw1", "hostname sw2", "end"})
}

func TestPlanIdenticalConfigsGiveNothing(t *testing.T) {
	cfg := "hostname sw1\nvlan 10\n"
	_, err := BuildRollbackPlan(cfg, cfg, ciscoProfile())
	if !errors.Is(err, ErrRollbackNothing) {
		t.Fatalf("очікували ErrRollbackNothing, отримали %v", err)
	}
}

func TestPlanRefusedForUnsupportedProfile(t *testing.T) {
	_, err := BuildRollbackPlan("a\n", "b\n", ApplyProfile{Supported: false})
	if !errors.Is(err, ErrRollbackNotSupported) {
		t.Fatalf("очікували ErrRollbackNotSupported, отримали %v", err)
	}
}

// Стеля на розмір плану — не косметика: різниця в сотні команд означає,
// що конфіги розійшлися цілком, і правильна дія тут не «залити», а
// віднести конфіг руками.
func TestPlanTooBigIsRefused(t *testing.T) {
	var b strings.Builder
	for i := 0; i < MaxRollbackCommands+50; i++ {
		b.WriteString("ip route 10.0.")
		b.WriteString(itoa(i))
		b.WriteString(".0 255.255.255.0 192.168.1.1\n")
	}
	_, err := BuildRollbackPlan("hostname sw1\n", "hostname sw1\n"+b.String(), ciscoProfile())
	if !errors.Is(err, ErrRollbackTooBig) {
		t.Fatalf("очікували ErrRollbackTooBig, отримали %v", err)
	}
}

// Підпис плану — те, чим звіряється «погодили одне, виконали інше».
// Він мусить залежати від структури, а не лише від склеєного тексту.
func TestPlanHashDistinguishesStructure(t *testing.T) {
	a := RollbackPlan{Commands: []string{"vlan 10", "name office"}}
	b := RollbackPlan{Commands: []string{"vlan 10 name office"}}
	if planHash(a) == planHash(b) {
		t.Error("дві різні структури плану дали однаковий підпис")
	}

	c := RollbackPlan{Commands: []string{"vlan 10"}, Manual: []string{"name office"}}
	d := RollbackPlan{Commands: []string{"vlan 10"}}
	if planHash(c) == planHash(d) {
		t.Error("перелік «прибрати вручну» не впливає на підпис")
	}
}

// Маскування секретів у тому, що побачить людина й журнал аудиту.
func TestRedactHidesSecrets(t *testing.T) {
	in := []string{
		"snmp-server community s3cr3t RO",
		"username admin password 7 0822455D0A16",
		"interface Gi0/1",
	}
	out := redactLines([]string{`community \S+`}, in)

	for _, s := range []string{"s3cr3t", "0822455D0A16"} {
		for _, line := range out {
			if strings.Contains(line, s) {
				t.Errorf("секрет %q лишився в рядку %q", s, line)
			}
		}
	}
	// Рядок без секрету має лишитись читабельним: маскується збіг, а не
	// весь рядок, інакше план перестає казати, ЩО саме змінюється.
	if out[2] != "interface Gi0/1" {
		t.Errorf("невинний рядок постраждав: %q", out[2])
	}
}

// Профіль із некомпільованим виразом не має ставати причиною показати
// пароль: запасний перелік працює завжди.
func TestRedactFallsBackOnBrokenPattern(t *testing.T) {
	out := redactLines([]string{`([`}, []string{"username admin password 7 0822455D0A16"})
	if strings.Contains(out[0], "0822455D0A16") {
		t.Errorf("секрет лишився попри поламаний вираз профілю: %q", out[0])
	}
}

// ---------------------------------------------------------------------

func assertCommands(t *testing.T, got, want []string) {
	t.Helper()
	if len(got) != len(want) {
		t.Fatalf("команд %d, очікували %d:\n  отримано: %v\n  очікували: %v",
			len(got), len(want), got, want)
	}
	for i := range want {
		if got[i] != want[i] {
			t.Fatalf("команда %d: %q, очікували %q\n  усі: %v", i, got[i], want[i], got)
		}
	}
}

func indexOf(in []string, s string) int {
	for i, v := range in {
		if v == s {
			return i
		}
	}
	return -1
}

func itoa(n int) string {
	if n == 0 {
		return "0"
	}
	var b []byte
	for n > 0 {
		b = append([]byte{byte('0' + n%10)}, b...)
		n /= 10
	}
	return string(b)
}