Netpulse_SasS/server/internal/store/devices_purge_test.go

package store

import (
	"context"
	"os"
	"testing"
	"time"

	"github.com/netpulse/netpulse/server/internal/gitstore"
)

// Перевірка повного видалення проти СПРАВЖНЬОЇ бази.
//
// Чому не мок і не перевірка SQL очима. Уся суть цієї дії в тому, що
// частину роботи робить не наш код, а каскади бази — і рівно там, де
// вони не спрацьовують, лишається сміття, якого ніхто не побачить.
// Тричі в цьому проєкті вже виявлялось, що дані не збігаються з
// оголошенням; довіряти тут опису таблиць не можна.
//
// Тест мовчки пропускається без NETPULSE_TEST_DSN: `go test ./...` не
// має вимагати бази. Запускати його треба на ОДНОРАЗОВІЙ базі —
// він видаляє те, що створив, і робить це назавжди.
//
//	docker run --rm -d --name np-test -e POSTGRES_PASSWORD=x \
//	  timescale/timescaledb:2.17.2-pg16
//	NETPULSE_TEST_DSN=postgres://postgres:x@np-test/np go test ./internal/store/ -run Purge
func TestPurgeDeviceLeavesNothing(t *testing.T) {
	dsn := os.Getenv("NETPULSE_TEST_DSN")
	if dsn == "" {
		t.Skip("NETPULSE_TEST_DSN не задано — перевірка проти бази пропускається")
	}
	ctx := context.Background()

	s, err := New(ctx, dsn)
	if err != nil {
		t.Fatalf("підключення: %v", err)
	}
	defer s.Close()
	s.UseGit(gitstore.New(t.TempDir()))

	var tenantID string
	slug := "purge-test-" + time.Now().Format("150405")
	if err := s.pool.QueryRow(ctx, `
		INSERT INTO core.tenants (slug, name) VALUES ($1, 'Тест видалення') RETURNING id::text
	`, slug).Scan(&tenantID); err != nil {
		t.Fatalf("кабінет: %v", err)
	}
	defer func() {
		_, _ = s.pool.Exec(context.Background(),
			`DELETE FROM core.tenants WHERE id = $1`, tenantID)
	}()

	var repoID, deviceID, ifaceID, secretID, alertID string
	var seriesID int64

	must := func(what string, err error) {
		t.Helper()
		if err != nil {
			t.Fatalf("%s: %v", what, err)
		}
	}

	must("репозиторій", s.pool.QueryRow(ctx, `
		INSERT INTO ncm.repos (tenant_id, name, storage_path, mirror_enabled, remote_url, remote_auth)
		VALUES ($1, 'default', '/tmp/x.git', true, 'https://git.example/np.git', 'https')
		RETURNING id::text`, tenantID).Scan(&repoID))

	must("хост", s.pool.QueryRow(ctx, `
		INSERT INTO inv.devices (tenant_id, name, address, kind)
		VALUES ($1, 'Леніна.21', '10.9.9.9', 'switch') RETURNING id::text`,
		tenantID).Scan(&deviceID))

	must("порт", s.pool.QueryRow(ctx, `
		INSERT INTO inv.interfaces (tenant_id, device_id, if_index, name)
		VALUES ($1, $2, 1, 'ge-0/0/1') RETURNING id::text`,
		tenantID, deviceID).Scan(&ifaceID))

	_, err = s.pool.Exec(ctx, `
		INSERT INTO core.checks (tenant_id, device_id, check_type) VALUES ($1, $2, 'icmp.ping')`,
		tenantID, deviceID)
	must("перевірка", err)

	must("ряд метрик", s.pool.QueryRow(ctx, `
		INSERT INTO ts.series (tenant_id, device_id, metric_key) VALUES ($1, $2, 'icmp.rtt')
		RETURNING id`, tenantID, deviceID).Scan(&seriesID))

	_, err = s.pool.Exec(ctx, `
		INSERT INTO ts.samples (ts, series_id, value)
		SELECT now() - (g || ' minutes')::interval, $1, g
		FROM generate_series(1, 500) g`, seriesID)
	must("виміри", err)

	// Ще 400 вимірів — десятиденної давності й СТИСНУТІ.
	//
	// Це не зайва ретельність. Стиснення в TimescaleDB тримає рядки не
	// в самому шматку, а в окремій таблиці, і зовнішній ключ оголошено
	// на шматку — тобто напрошується висновок, що видалення стиснутого
	// не дістане. Висновок хибний (2.17.2 розтискає під DML сама), але
	// перевіряти його треба тут, а не в голові: на бойових інсталяціях
	// стиснуте — це майже вся телеметрія.
	_, err = s.pool.Exec(ctx, `
		INSERT INTO ts.samples (ts, series_id, value)
		SELECT now() - interval '10 days' + (g || ' seconds')::interval, $1, g
		FROM generate_series(1, 400) g`, seriesID)
	must("старі виміри", err)

	_, err = s.pool.Exec(ctx, `
		SELECT compress_chunk(format('%I.%I', chunk_schema, chunk_name)::regclass)
		FROM timescaledb_information.chunks
		WHERE hypertable_schema = 'ts' AND hypertable_name = 'samples'
		  AND NOT is_compressed AND range_end < now() - interval '2 days'`)
	must("стиснення шматка", err)

	_, err = s.pool.Exec(ctx, `
		INSERT INTO ts.icmp_samples (ts, device_id, tenant_id, reachable)
		SELECT now() - (g || ' minutes')::interval, $1, $2, true
		FROM generate_series(1, 300) g`, deviceID, tenantID)
	must("icmp", err)

	_, err = s.pool.Exec(ctx, `
		INSERT INTO ts.if_counters (ts, interface_id, device_id, tenant_id, in_octets)
		SELECT now() - (g || ' minutes')::interval, $1, $2, $3, g
		FROM generate_series(1, 300) g`, ifaceID, deviceID, tenantID)
	must("лічильники портів", err)

	must("алерт", s.pool.QueryRow(ctx, `
		INSERT INTO alr.alerts (tenant_id, device_id, severity, title, dedup_key)
		VALUES ($1, $2, 'high', 'тест', 'k1') RETURNING id::text`,
		tenantID, deviceID).Scan(&alertID))

	_, err = s.pool.Exec(ctx, `
		INSERT INTO alr.notifications (tenant_id, alert_id) VALUES ($1, $2)`,
		tenantID, alertID)
	must("сповіщення", err)

	_, err = s.pool.Exec(ctx, `
		INSERT INTO alr.alerts_history (ts, id, tenant_id, device_id, severity, title, started_at)
		VALUES (now(), core.new_id(), $1, $2, 'high', 'тест', now())`, tenantID, deviceID)
	must("історія алертів", err)

	// Тіло конфігу в core.secrets — найважливіше з того, чого каскад не
	// прибирає: посилання оголошено ON DELETE SET NULL.
	must("тіло конфігу", s.pool.QueryRow(ctx, `
		INSERT INTO core.secrets (tenant_id, kind, key_id, nonce, ciphertext, auth_tag)
		VALUES ($1, 'generic', 'k1', '\x00', '\x01', '\x02') RETURNING id::text`,
		tenantID).Scan(&secretID))

	_, err = s.pool.Exec(ctx, `
		INSERT INTO ncm.configs (tenant_id, device_id, repo_id, commit_sha, blob_sha,
		                         branch, path, size_bytes, content_hash, body_secret_id)
		VALUES ($1, $2, $3, 'abc', 'def', 'device/Леніна.21-10.9.9.9',
		        'Леніна.21/running.cfg', 4096, '\x00', $4)`,
		tenantID, deviceID, repoID, secretID)
	must("версія конфігу", err)

	// --- сама дія ---

	res, err := s.PurgeDevices(ctx, tenantID, Scope{Unrestricted: true}, []string{deviceID})
	if err != nil {
		t.Fatalf("видалення: %v", err)
	}
	if len(res.Purged) != 1 {
		t.Fatalf("очікували один видалений хост, отримали %d (%+v)", len(res.Purged), res.Failed)
	}
	got := res.Purged[0]
	if got.Name != "Леніна.21" || got.Address != "10.9.9.9" {
		t.Errorf("ім'я й адреса мають доїхати до звіту (це те, що піде в аудит): %+v", got)
	}
	if got.Samples != 900 {
		t.Errorf("вимірів прибрано %d, очікували 900 (з них 400 — зі стиснутого шматка)",
			got.Samples)
	}
	if got.Configs != 1 || got.FreedBytes != 4096 {
		t.Errorf("версій %d, звільнено %d — очікували 1 і 4096", got.Configs, got.FreedBytes)
	}

	// --- що лишилось ---

	check := func(what, sql string, args ...any) {
		t.Helper()
		var n int
		if err := s.pool.QueryRow(ctx, sql, args...).Scan(&n); err != nil {
			t.Fatalf("%s: %v", what, err)
		}
		if n != 0 {
			t.Errorf("%s: лишилось %d рядків", what, n)
		}
	}

	check("хост", `SELECT count(*) FROM inv.devices WHERE id = $1`, deviceID)
	check("перевірки", `SELECT count(*) FROM core.checks WHERE device_id = $1`, deviceID)
	check("порти", `SELECT count(*) FROM inv.interfaces WHERE device_id = $1`, deviceID)
	check("ряди метрик", `SELECT count(*) FROM ts.series WHERE device_id = $1`, deviceID)
	check("виміри", `SELECT count(*) FROM ts.samples WHERE series_id = $1`, seriesID)
	check("icmp", `SELECT count(*) FROM ts.icmp_samples WHERE device_id = $1`, deviceID)
	check("лічильники портів", `SELECT count(*) FROM ts.if_counters WHERE device_id = $1`, deviceID)
	check("алерти", `SELECT count(*) FROM alr.alerts WHERE device_id = $1`, deviceID)
	check("сповіщення", `SELECT count(*) FROM alr.notifications WHERE alert_id = $1`, alertID)
	check("історія алертів", `SELECT count(*) FROM alr.alerts_history WHERE device_id = $1`, deviceID)
	check("версії конфігу", `SELECT count(*) FROM ncm.configs WHERE device_id = $1`, deviceID)
	// Найважливіший рядок тесту: шифротекст, на який більше ніщо не
	// посилається, лишився б у базі назавжди.
	check("зашифровані тіла", `SELECT count(*) FROM core.secrets WHERE id = $1`, secretID)

	// --- гілка стала в чергу ---

	var branch string
	if err := s.pool.QueryRow(ctx, `
		SELECT branch FROM ncm.ref_deletions WHERE tenant_id = $1 ORDER BY branch LIMIT 1
	`, tenantID).Scan(&branch); err != nil {
		t.Fatalf("черга видалень гілок порожня: %v", err)
	}
	if branch != "device/Леніна.21-10.9.9.9" {
		t.Errorf("у черзі гілка %q", branch)
	}
	// Рядок черги мусить ПЕРЕЖИТИ видалення хоста — заради цього на
	// device_id і не поставлено зовнішнього ключа.
	var deviceIDInQueue *string
	if err := s.pool.QueryRow(ctx, `
		SELECT device_id::text FROM ncm.ref_deletions WHERE tenant_id = $1 LIMIT 1
	`, tenantID).Scan(&deviceIDInQueue); err != nil {
		t.Fatalf("рядок черги: %v", err)
	}
	if deviceIDInQueue == nil || *deviceIDInQueue != deviceID {
		t.Errorf("у черзі має лишитись id видаленого хоста, маємо %v", deviceIDInQueue)
	}

	// Такт колектора бачить цей рядок і знає, що дзеркало налаштоване.
	// Без цієї перевірки помилка в JOIN'ах вибірки виявилась би тоді,
	// коли гілки мовчки не прибирались би тижнями.
	tasks, err := s.PendingRefDeletes(ctx, nil, 100)
	if err != nil {
		t.Fatalf("вибірка черги: %v", err)
	}
	var mine *RefDeleteTask
	for i := range tasks {
		if tasks[i].TenantID == tenantID {
			mine = &tasks[i]
			break
		}
	}
	if mine == nil {
		t.Fatal("такт не побачив рядка черги")
	}
	if !mine.MirrorReady {
		t.Error("дзеркало налаштоване — такт мав це побачити")
	}
	if mine.LocalDone {
		t.Error("локальну гілку ще не прибирали цим шляхом")
	}
	if mine.Remote.URL != "https://git.example/np.git" {
		t.Errorf("адреса дзеркала не доїхала: %q", mine.Remote.URL)
	}
}