Scoreboard/server/internal/export/backup_test.go

package export

import (
	"context"
	"io"
	"log/slog"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"
)

func TestBackupAndRetention(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)

	dir := t.TempDir()
	base := time.Date(2026, 9, 9, 10, 0, 0, 0, time.Local)

	info, err := Backup(db, BackupOptions{Dir: dir, Prefix: "event", Reason: "publish", Keep: 3, Now: base})
	if err != nil {
		t.Fatalf("备份: %v", err)
	}
	if info.Size == 0 || info.SHA256 == "" {
		t.Errorf("备份信息不完整: %+v", info)
	}
	if info.Reason != "publish" {
		t.Errorf("备份原因 = %q，期望 publish", info.Reason)
	}
	if _, err := os.Stat(info.Path); err != nil {
		t.Fatalf("备份文件不存在: %v", err)
	}

	// 快照必须可打开，且数据与源库一致。
	bdb := openSQLite(t, info.Path)
	if got := countRows(t, bdb, "teams"); got != 2 {
		t.Errorf("备份内 teams = %d，期望 2", got)
	}
	if got := countRows(t, bdb, "score_ledger"); got != 2 {
		t.Errorf("备份内 score_ledger = %d，期望 2", got)
	}
	_ = bdb.Close()

	// 再生成 5 份，Keep=3 应只留最近 3 份。
	for i := 1; i <= 5; i++ {
		if _, err := Backup(db, BackupOptions{
			Dir: dir, Prefix: "event", Reason: "auto", Keep: 3,
			Now: base.Add(time.Duration(i) * time.Minute),
		}); err != nil {
			t.Fatalf("第 %d 次备份: %v", i, err)
		}
	}
	list, err := ListBackups(dir, "event")
	if err != nil {
		t.Fatalf("列出备份: %v", err)
	}
	if len(list) != 3 {
		t.Fatalf("保留份数 = %d，期望 3", len(list))
	}
	if list[0].Reason != "auto" {
		t.Errorf("最新备份原因 = %q，期望 auto", list[0].Reason)
	}

	latest, ok, err := LatestBackup(dir, "event")
	if err != nil || !ok {
		t.Fatalf("最近备份: ok=%v err=%v", ok, err)
	}
	if !latest.CreatedAt.Equal(base.Add(5 * time.Minute)) {
		t.Errorf("最近备份时间 = %s，期望 %s", latest.CreatedAt, base.Add(5*time.Minute))
	}

	if _, err := PruneBackups(dir, "event", 1); err != nil {
		t.Fatalf("手动清理: %v", err)
	}
	list, err = ListBackups(dir, "event")
	if err != nil {
		t.Fatalf("清理后列出备份: %v", err)
	}
	if len(list) != 1 {
		t.Errorf("清理后份数 = %d，期望 1", len(list))
	}
}

func TestBackupBeforePublishAndUniqueNames(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)

	dir := t.TempDir()
	base := time.Date(2026, 9, 9, 11, 0, 0, 0, time.Local)

	a, err := Backup(db, BackupOptions{Dir: dir, Prefix: "event", Now: base, SkipPrune: true})
	if err != nil {
		t.Fatalf("备份 A: %v", err)
	}
	b, err := Backup(db, BackupOptions{Dir: dir, Prefix: "event", Now: base, SkipPrune: true})
	if err != nil {
		t.Fatalf("备份 B: %v", err)
	}
	if a.Path == b.Path {
		t.Errorf("同一秒的两份备份重名: %s", a.Path)
	}

	info, err := BackupBeforePublish(db, BackupOptions{Dir: dir, Prefix: "event", Keep: 20, Now: base.Add(time.Hour)})
	if err != nil {
		t.Fatalf("发布前备份: %v", err)
	}
	if info.Reason != "publish" {
		t.Errorf("发布前备份原因 = %q，期望 publish", info.Reason)
	}
	if filepath.Dir(info.Path) != dir {
		t.Errorf("备份目录 = %q，期望 %q", filepath.Dir(info.Path), dir)
	}
}

func TestListBackupsMissingDir(t *testing.T) {
	list, err := ListBackups(filepath.Join(t.TempDir(), "不存在"), "event")
	if err != nil {
		t.Fatalf("目录不存在不应报错: %v", err)
	}
	if len(list) != 0 {
		t.Errorf("备份数 = %d，期望 0", len(list))
	}
	if _, ok, err := LatestBackup(filepath.Join(t.TempDir(), "不存在"), "event"); err != nil || ok {
		t.Errorf("空目录的最近备份: ok=%v err=%v", ok, err)
	}
}

// 间隔 <=0 关闭任务；未配置备份目录时安全跳过（不 panic、不生成文件）。
func TestStartAutoDisabled(t *testing.T) {
	dir := t.TempDir()
	svc := NewService(nil, nil, dir, 20, testLogger())
	ctx := context.Background()

	svc.StartAuto(ctx, 0)
	svc.StartAuto(ctx, -time.Minute)

	entries, err := os.ReadDir(dir)
	if err != nil {
		t.Fatalf("读取备份目录: %v", err)
	}
	if len(entries) != 0 {
		t.Fatalf("间隔 <=0 不应生成备份，实际 %d 个文件", len(entries))
	}

	// 未配置备份目录：只记日志并跳过，不能 panic。
	NewService(nil, nil, "", 20, testLogger()).StartAuto(ctx, time.Minute)
}

// 定时任务按间隔生成 auto 备份。
func TestStartAutoBacksUp(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)
	dir := t.TempDir()

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	NewService(nil, db, dir, 20, testLogger()).StartAuto(ctx, 10*time.Millisecond)

	deadline := time.Now().Add(10 * time.Second)
	for {
		list, err := ListBackups(dir, "event")
		if err != nil {
			t.Fatalf("列出备份: %v", err)
		}
		if len(list) > 0 {
			if list[0].Reason != "auto" {
				t.Fatalf("定时备份原因 = %q，期望 auto", list[0].Reason)
			}
			return
		}
		if time.Now().After(deadline) {
			t.Fatal("10 秒内未生成定时备份")
		}
		time.Sleep(10 * time.Millisecond)
	}
}

// 超过保留份数时删除最旧的备份。
func TestServiceRunPrunesOldBackups(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)
	dir := t.TempDir()
	base := time.Date(2026, 1, 1, 0, 0, 0, 0, time.Local)
	for i := 0; i < 3; i++ {
		if _, err := Backup(db, BackupOptions{
			Dir: dir, Prefix: "event", Reason: "auto", SkipPrune: true,
			Now: base.Add(time.Duration(i) * time.Minute),
		}); err != nil {
			t.Fatalf("预置第 %d 份备份: %v", i, err)
		}
	}

	svc := NewService(nil, db, dir, 2, testLogger())
	if _, err := svc.RunEvent("auto"); err != nil {
		t.Fatalf("RunEvent: %v", err)
	}

	list, err := ListBackups(dir, "event")
	if err != nil {
		t.Fatalf("列出备份: %v", err)
	}
	if len(list) != 2 {
		t.Fatalf("保留份数 = %d，期望 2", len(list))
	}
	if _, err := os.Stat(filepath.Join(dir, "event-auto-20260101-000000.db")); !os.IsNotExist(err) {
		t.Errorf("最旧的备份应被删除，err=%v", err)
	}
}

// 并发触发时必须等待同一把锁，保证同一时刻只有一个 VACUUM INTO 在跑。
func TestServiceRunMutualExclusion(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)
	svc := NewService(nil, db, t.TempDir(), 20, testLogger())

	svc.mu.Lock()
	done := make(chan error, 1)
	go func() {
		_, err := svc.RunEvent("auto")
		done <- err
	}()
	select {
	case err := <-done:
		t.Fatalf("RunEvent 未等待互斥锁就返回: %v", err)
	case <-time.After(100 * time.Millisecond):
	}
	svc.mu.Unlock()

	select {
	case err := <-done:
		if err != nil {
			t.Fatalf("RunEvent: %v", err)
		}
	case <-time.After(10 * time.Second):
		t.Fatal("RunEvent 超时未完成")
	}
}

// prefix 为空（列出全部备份）时要剥掉已识别的前缀，不能把 event-/system- 拼进原因。
func TestReasonFromNameWithoutPrefix(t *testing.T) {
	cases := []struct{ name, want string }{
		{"event-auto-20260909-213614.db", "auto"},
		{"event-publish-20260909-213614-2.db", "publish"},
		{"system-manual-20260909-213614.db", "manual"},
		{"db-manual-20260909-213614.db", "manual"},
	}
	for _, c := range cases {
		if got := reasonFromName(c.name, ""); got != c.want {
			t.Errorf("reasonFromName(%q, \"\") = %q，期望 %q", c.name, got, c.want)
		}
	}
}

// ListBackups 不传 prefix 时也要解析出可读原因（管理端「备份」面板按原因分列）。
func TestListBackupsParsesReasonWithoutPrefix(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)
	dir := t.TempDir()
	base := time.Date(2026, 9, 9, 12, 0, 0, 0, time.Local)

	if _, err := Backup(db, BackupOptions{Dir: dir, Prefix: "event", Reason: "auto", Now: base, SkipPrune: true}); err != nil {
		t.Fatalf("赛事库备份: %v", err)
	}
	if _, err := Backup(db, BackupOptions{Dir: dir, Prefix: "system", Reason: "manual", Now: base.Add(time.Minute), SkipPrune: true}); err != nil {
		t.Fatalf("系统库备份: %v", err)
	}

	list, err := ListBackups(dir, "")
	if err != nil {
		t.Fatalf("列出全部备份: %v", err)
	}
	if len(list) != 2 {
		t.Fatalf("备份数 = %d，期望 2", len(list))
	}
	want := map[string]string{"event": "auto", "system": "manual"}
	for _, b := range list {
		var prefix string
		for p := range want {
			if strings.HasPrefix(b.Name, p+"-") {
				prefix = p
			}
		}
		if prefix == "" {
			t.Fatalf("无法识别备份前缀: %s", b.Name)
		}
		if b.Reason != want[prefix] {
			t.Errorf("%s 的原因 = %q，期望 %q", b.Name, b.Reason, want[prefix])
		}
	}
}

// 非 NotExist 错误不能让选名函数死循环（它持锁会阻塞全部备份）。
func TestUniqueBackupPathStopsOnError(t *testing.T) {
	if os.Geteuid() == 0 {
		t.Skip("root 不受目录权限限制")
	}
	dir := filepath.Join(t.TempDir(), "locked")
	if err := os.Mkdir(dir, 0o755); err != nil {
		t.Fatalf("创建目录: %v", err)
	}
	if err := os.Chmod(dir, 0o000); err != nil {
		t.Fatalf("改权限: %v", err)
	}
	t.Cleanup(func() { _ = os.Chmod(dir, 0o755) })

	done := make(chan error, 1)
	go func() {
		_, err := uniqueBackupPath(dir, "event", "auto", time.Now())
		done <- err
	}()
	select {
	case err := <-done:
		if err == nil {
			t.Fatal("目录不可读应返回错误")
		}
	case <-time.After(5 * time.Second):
		t.Fatal("uniqueBackupPath 在非 NotExist 错误上死循环")
	}
}

// 同一秒重复备份会带 -2 之类的序号，原因解析不能把它当成时间的一部分。
func TestReasonFromNameWithSequence(t *testing.T) {
	cases := []struct{ name, prefix, want string }{
		{"event-auto-20260909-213614.db", "event", "auto"},
		{"event-auto-20260909-213614-2.db", "event", "auto"},
		{"event-publish-20260909-213614-10.db", "event", "publish"},
		{"system-manual-20260909-213614.db", "system", "manual"},
	}
	for _, c := range cases {
		if got := reasonFromName(c.name, c.prefix); got != c.want {
			t.Errorf("reasonFromName(%q) = %q，期望 %q", c.name, got, c.want)
		}
	}
}

func testLogger() *slog.Logger {
	return slog.New(slog.NewTextHandler(io.Discard, nil))
}