Scoreboard/server/main_test.go

package main

import (
	"bytes"
	"log/slog"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"git.yeij.top/AskaEth/Scoreboard/server/internal/export"
	"git.yeij.top/AskaEth/Scoreboard/server/internal/httpapi"
)

// CLI 备份必须用 event 前缀（与备份服务一致），否则 PruneBackups 按 <prefix>-* 清理不到，
// 备份目录会只增不减。
func TestRunBackupUsesEventPrefix(t *testing.T) {
	root := t.TempDir()
	dataDir := filepath.Join(root, "data")
	writeEventDB(t, dataDir)
	cfgPath := writeConfig(t, root, dataDir)

	if err := runBackup([]string{"-config", cfgPath, "-project", "default", "-reason", "manual"}); err != nil {
		t.Fatalf("runBackup: %v", err)
	}

	entries, err := os.ReadDir(filepath.Join(dataDir, "backups"))
	if err != nil {
		t.Fatalf("读取备份目录: %v", err)
	}
	eventBackup := false
	for _, e := range entries {
		if strings.HasPrefix(e.Name(), "default-") {
			t.Errorf("CLI 备份不应使用项目名前缀: %s", e.Name())
		}
		if strings.HasPrefix(e.Name(), "event-manual-") {
			eventBackup = true
		}
	}
	if !eventBackup {
		t.Errorf("未生成 event- 前缀的赛事库备份，实际文件: %v", entries)
	}
}

// 数据目录搬到安装目录之外后，CLI 备份必须跟 -data 走，否则备份的是旧目录（甚至是空目录）。
func TestRunBackupDataFlagOverridesConfig(t *testing.T) {
	root := t.TempDir()
	cfgDataDir := filepath.Join(root, "cfg-data")
	flagDataDir := filepath.Join(root, "flag-data")
	writeEventDB(t, cfgDataDir)
	writeEventDB(t, flagDataDir)
	cfgPath := writeConfig(t, root, cfgDataDir)

	if err := runBackup([]string{"-config", cfgPath, "-project", "default", "-reason", "manual", "-data", flagDataDir}); err != nil {
		t.Fatalf("runBackup: %v", err)
	}

	entries, err := os.ReadDir(filepath.Join(flagDataDir, "backups"))
	if err != nil {
		t.Fatalf("读取 -data 指向的备份目录: %v", err)
	}
	if len(entries) == 0 {
		t.Fatalf("-data 指向的目录里没有备份文件")
	}
	if _, err := os.Stat(filepath.Join(cfgDataDir, "backups")); !os.IsNotExist(err) {
		t.Fatalf("配置里的数据目录不应被写入: %v", err)
	}
}

// -data 传空串等于不传：仍然用配置文件里的数据目录，便携与手工运行的行为不变。
func TestRunBackupEmptyDataFlagKeepsConfig(t *testing.T) {
	root := t.TempDir()
	cfgDataDir := filepath.Join(root, "cfg-data")
	writeEventDB(t, cfgDataDir)
	cfgPath := writeConfig(t, root, cfgDataDir)

	if err := runBackup([]string{"-config", cfgPath, "-project", "default", "-reason", "manual", "-data", ""}); err != nil {
		t.Fatalf("runBackup: %v", err)
	}

	if _, err := os.Stat(filepath.Join(cfgDataDir, "backups")); err != nil {
		t.Fatalf("空 -data 时应写配置里的数据目录: %v", err)
	}
}

// writeEventDB 造一个空的赛事库；runBackup 只在 event.db 存在时备份赛事库，空库也走同一条 VACUUM INTO 路径。
func writeEventDB(t *testing.T, dataDir string) {
	t.Helper()
	writeProjectEventDB(t, dataDir, defaultProjectName)
}

// writeProjectEventDB 在指定项目下造一个空的赛事库。
func writeProjectEventDB(t *testing.T, dataDir, project string) {
	t.Helper()
	projDir := filepath.Join(dataDir, "event_projs", project)
	if err := os.MkdirAll(projDir, 0o755); err != nil {
		t.Fatalf("创建赛事目录: %v", err)
	}
	if err := os.WriteFile(filepath.Join(projDir, "event.db"), nil, 0o644); err != nil {
		t.Fatalf("创建赛事库: %v", err)
	}
}

// writeActiveProjectFile 写记忆文件，模拟「上次打开过的赛事」。
func writeActiveProjectFile(t *testing.T, dataDir, name string) {
	t.Helper()
	writeActiveProjectRaw(t, dataDir, name+"\n")
}

// writeActiveProjectRaw 直接写记忆文件原文，用于构造被改坏的记忆文件。
func writeActiveProjectRaw(t *testing.T, dataDir, content string) {
	t.Helper()
	if err := os.MkdirAll(dataDir, 0o755); err != nil {
		t.Fatalf("创建数据目录: %v", err)
	}
	if err := os.WriteFile(filepath.Join(dataDir, httpapi.ActiveProjectFile), []byte(content), 0o644); err != nil {
		t.Fatalf("写记忆文件: %v", err)
	}
}

// 启动解析顺序：显式 -project > 记忆文件里的上一次赛事 > default。
// 这正是「导入赛事包后管理面板还是空的」的修复点：Console 不传 -project，只能靠记忆文件。
func TestResolveProjectNamePriority(t *testing.T) {
	dataDir := t.TempDir()

	name, source, err := resolveProjectName(dataDir, "")
	if err != nil || name != defaultProjectName || source != projectSourceDefault {
		t.Fatalf("没有记忆文件时应回落 default，得到 %q/%q/%v", name, source, err)
	}
	name, source, err = resolveProjectName(dataDir, "   ")
	if err != nil || name != defaultProjectName || source != projectSourceDefault {
		t.Fatalf("空白 -project 等于没传，得到 %q/%q/%v", name, source, err)
	}

	writeActiveProjectFile(t, dataDir, "秋季赛")
	name, source, err = resolveProjectName(dataDir, "")
	if err != nil || name != "秋季赛" || source != projectSourceFile {
		t.Fatalf("有记忆文件时应用它，得到 %q/%q/%v", name, source, err)
	}

	name, source, err = resolveProjectName(dataDir, "冬季赛")
	if err != nil || name != "冬季赛" || source != projectSourceFlag {
		t.Fatalf("显式 -project 应压过记忆文件，得到 %q/%q/%v", name, source, err)
	}

	// 显式传了非法名字必须报错退出，不能静默回落到别的赛事——那会让现场打开错的库。
	if _, _, err := resolveProjectName(dataDir, "../逃逸"); err == nil {
		t.Fatal("非法 -project 应报错")
	}
	if _, _, err := resolveProjectName(dataDir, "a/b"); err == nil {
		t.Fatal("含分隔符的 -project 应报错")
	}
}

// 记忆文件被手工改坏时回落 default，而不是打开一个非法或半截的目录。
func TestResolveProjectNameInvalidMemoryFile(t *testing.T) {
	for _, tc := range []struct{ name, content string }{
		{"路径穿越", "../逃逸\n"},
		{"多行", "好名字\n坏名字\n"},
		{"只有空白", " \n"},
		{"末尾点号", "赛事.\n"},
	} {
		dataDir := t.TempDir()
		writeActiveProjectRaw(t, dataDir, tc.content)
		name, source, err := resolveProjectName(dataDir, "")
		if err != nil || name != defaultProjectName || source != projectSourceDefault {
			t.Errorf("%s：非法记忆文件应回落 default，得到 %q/%q/%v", tc.name, name, source, err)
		}
	}

	// 数据目录还不存在（首次启动）同样回落 default，不能报错拦启动。
	name, source, err := resolveProjectName(filepath.Join(t.TempDir(), "还没有"), "")
	if err != nil || name != defaultProjectName || source != projectSourceDefault {
		t.Fatalf("数据目录不存在时应回落 default，得到 %q/%q/%v", name, source, err)
	}
}

// CLI 备份必须跟服务端打开同一个赛事库：项目名同样从记忆文件解析。
func TestRunBackupUsesRememberedProject(t *testing.T) {
	root := t.TempDir()
	dataDir := filepath.Join(root, "data")
	writeProjectEventDB(t, dataDir, "秋季赛")
	writeActiveProjectFile(t, dataDir, "秋季赛")
	cfgPath := writeConfig(t, root, dataDir)

	if err := runBackup([]string{"-config", cfgPath, "-reason", "manual"}); err != nil {
		t.Fatalf("runBackup: %v", err)
	}

	entries, err := os.ReadDir(filepath.Join(dataDir, "backups"))
	if err != nil {
		t.Fatalf("读取备份目录: %v", err)
	}
	eventBackup := false
	for _, e := range entries {
		if strings.HasPrefix(e.Name(), "event-manual-") {
			eventBackup = true
		}
	}
	if !eventBackup {
		t.Fatalf("应按记忆文件里的 秋季赛 备份赛事库，实际文件: %v", entries)
	}
	// 备份是只读操作，绝不能顺手改掉「下次打开哪个赛事」。
	raw, err := os.ReadFile(filepath.Join(dataDir, httpapi.ActiveProjectFile))
	if err != nil || strings.TrimSpace(string(raw)) != "秋季赛" {
		t.Fatalf("记忆文件不该被备份改写，得到 %q / %v", raw, err)
	}
}

// 显式 -project 优先于记忆文件：指到没有 event.db 的项目时就不备份赛事库。
func TestRunBackupExplicitProjectBeatsMemory(t *testing.T) {
	root := t.TempDir()
	dataDir := filepath.Join(root, "data")
	writeProjectEventDB(t, dataDir, "秋季赛")
	writeActiveProjectFile(t, dataDir, "秋季赛")
	cfgPath := writeConfig(t, root, dataDir)

	if err := runBackup([]string{"-config", cfgPath, "-project", "没导入过", "-reason", "manual"}); err != nil {
		t.Fatalf("runBackup: %v", err)
	}

	entries, err := os.ReadDir(filepath.Join(dataDir, "backups"))
	if err != nil {
		t.Fatalf("读取备份目录: %v", err)
	}
	for _, e := range entries {
		if strings.HasPrefix(e.Name(), "event-") {
			t.Fatalf("显式 -project 指到空项目时不该备份赛事库，实际文件: %s", e.Name())
		}
	}
}

// writeConfig 写一份只指定数据目录的最小配置，返回配置路径。
func writeConfig(t *testing.T, dir, dataDir string) string {
	t.Helper()
	path := filepath.Join(dir, "config.yaml")
	raw := "dataDir: " + dataDir + "\nserver:\n  port: 19540\n"
	if err := os.WriteFile(path, []byte(raw), 0o644); err != nil {
		t.Fatalf("写配置: %v", err)
	}
	return path
}

// 现场按文档用 findstr 搜纯 ASCII 锚找初始密码；中文匹配在 chcp 936/65001 下不可靠。
func TestInitialAdminBannerAsciiAnchor(t *testing.T) {
	const anchor = "=== INITIAL ADMIN CREATED (password above) ==="
	banner := initialAdminBanner("admin", "s3cret-pass")
	if !strings.Contains(banner, anchor) {
		t.Fatalf("banner 缺少可搜索的 ASCII 锚 %q:\n%s", anchor, banner)
	}
	if !strings.Contains(banner, "s3cret-pass") {
		t.Fatalf("banner 应包含初始密码:\n%s", banner)
	}
	// 锚在密码之后，文案 password above 才成立。
	if strings.Index(banner, "s3cret-pass") > strings.Index(banner, anchor) {
		t.Fatalf("ASCII 锚应在密码行之后:\n%s", banner)
	}
}

// ---------- C35：恢复标记的启动告警 ----------

// writeRestoreMarker 用真实写入路径（export.WritePendingRestore）造一份恢复标记，
// 字段名与落盘格式都跟「一键恢复」写下的那份一模一样。
func writeRestoreMarker(t *testing.T, dataDir string, p export.PendingRestore) string {
	t.Helper()
	path, err := export.WritePendingRestore(dataDir, p)
	if err != nil {
		t.Fatalf("写恢复标记: %v", err)
	}
	return path
}

// sampleRestoreMarker 是一份典型的「恢复写到一半进程没了」的标记。
func sampleRestoreMarker() export.PendingRestore {
	return export.PendingRestore{
		Kind:        export.RestoreKindEvent,
		Backup:      "/data/backups/event-manual-20260911-201500.db",
		BackupName:  "event-manual-20260911-201500.db",
		Target:      "/data/event_projs/autumn/event.db",
		SafetyCopy:  "/data/backups/pre-restore-event-20260911-201503.db",
		Operator:    "admin#1",
		RequestedAt: time.Date(2026, 9, 11, 20, 15, 3, 0, time.UTC),
	}
}

// 恢复标记留在数据目录里 = 上一次恢复没走完。启动时必须读到它并告警，
// 且告警要带上「盖的是哪个库、用哪份备份、退回用的安全副本是哪份、谁点的」——
// 只说一句「有残留文件」，现场还是不知道该怎么办。
func TestWarnPendingRestoreReportsMarker(t *testing.T) {
	dataDir := t.TempDir()
	marker := writeRestoreMarker(t, dataDir, sampleRestoreMarker())

	buf := &bytes.Buffer{}
	logger := slog.New(slog.NewJSONHandler(buf, nil))
	warnPendingRestore(logger, dataDir)

	logs := buf.String()
	for _, want := range []string{
		`"level":"WARN"`,
		"未收尾",
		sampleRestoreMarker().BackupName,
		sampleRestoreMarker().Target,
		sampleRestoreMarker().SafetyCopy,
		sampleRestoreMarker().Operator,
		"2026-09-11T20:15:03Z",
	} {
		if !strings.Contains(logs, want) {
			t.Fatalf("启动告警应含 %q，得到：\n%s", want, logs)
		}
	}
	// 只告警、不删：这份标记是那次未收尾恢复的唯一记录，删不删该由操作员决定。
	if _, err := os.Stat(marker); err != nil {
		t.Fatalf("告警不该动这份标记（它是唯一线索）: %v", err)
	}
}

// 没有标记时一个字都不许刷：正常启动的日志里出现「未收尾」会把人引向不存在的事故。
func TestWarnPendingRestoreSilentWithoutMarker(t *testing.T) {
	buf := &bytes.Buffer{}
	logger := slog.New(slog.NewJSONHandler(buf, nil))
	warnPendingRestore(logger, t.TempDir())
	if buf.Len() != 0 {
		t.Fatalf("没有恢复标记时不该产生任何日志，得到：\n%s", buf.String())
	}
}

// 标记内容坏了（写了一半 / 被人手工改坏）不能拦启动、也不能静默：要告警说明这个文件有问题。
func TestWarnPendingRestoreToleratesBrokenMarker(t *testing.T) {
	dataDir := t.TempDir()
	path := filepath.Join(dataDir, export.PendingRestoreFile)
	if err := os.WriteFile(path, []byte("{不是 JSON"), 0o644); err != nil {
		t.Fatalf("写坏标记: %v", err)
	}

	buf := &bytes.Buffer{}
	logger := slog.New(slog.NewJSONHandler(buf, nil))
	warnPendingRestore(logger, dataDir)

	if !strings.Contains(buf.String(), "无法解析") || !strings.Contains(buf.String(), path) {
		t.Fatalf("坏标记应告警并指出文件路径，得到：\n%s", buf.String())
	}
}

// 光测上面那几个函数还不够：漏掉 main 里那一行调用，标记照样没人读（这正是 C35 的原状——
// 写入方齐全、读取方为零）。这里连同调用点一起钉住，参考网页侧「模板契约断言」的做法。
func TestMainReadsPendingRestoreMarkerAtStartup(t *testing.T) {
	raw, err := os.ReadFile("main.go")
	if err != nil {
		t.Fatalf("读 main.go: %v", err)
	}
	if !strings.Contains(string(raw), "warnPendingRestore(logger, cfg.DataDir)") {
		t.Fatalf("main.go 里找不到启动时读恢复标记的调用：标记又会变回没人读的孤儿文件")
	}
}