AskaEth
1b8a37ff8c
三件事合成一次提交（其中两件都落在 handlers_config.go，无法按文件拆开）： 一、分工作表报名模板（新增能力） - 新增 GET /api/entries/template.xlsx：按当前赛事的「小项 × 组别」生成模板， 一个小项组别一张工作表，工作表名 = <小项>@<组别>（31 字符上限、重名自动去重）。 - 导入解析器认工作表名还原小项 + 组别；若与表内列冲突则报错，不静默取其一。 - 小项名与组别名禁用 @，基础数据界面 / 规则包导入 / 服务端校验三处一并拦截。 - 单表 CSV/XLSX 导入路径不回归。 二、号码布判重（修误判） - 旧逻辑依赖证件号本身，而证件号是可选字段 → 同一个人报多个项目会被整块拦下。 - 改为：号码布相同且证件号相同 → 判定为同一人报多项，放行； 号码布相同且证件号都能填且不同 → 仍报错（真抢号）；一方证件号为空 → 放行并给提示。 - 团体行的号码布一并纳入查重。 三、自动备份的关停与落盘（修数据安全隐患） - export.Service 增加 Wait()：StartAuto 的协程进 WaitGroup，关停时 join（10 秒上限， 超时只记 WARN 不拖死关闭），不再在备份写到一半时退出。 - vacuumInto 改为先写 <最终名>.tmp-<随机> 再 rename，失败则删临时文件； Backup / SafetySnapshot / ExportProjectZip 三个调用方一并受益。 - 新增 isFinalBackupName，ListBackups / safetyCopies / KindOfBackupName 统一过滤中间文件， 避免半截 .db 被列进备份列表、进而被「一键恢复」选中。 文档：docs/ 五份（使用手册 / 报名名单导入规范 / 升级说明 / 部署指南 / 上线检查清单）同步。
411 lines
12 KiB
Go
411 lines
12 KiB
Go
package export
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"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()
|
|
|
|
const interval = 10 * time.Millisecond
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
// 备份跑在后台协程里，而 t.TempDir 的清理是把目录整个删掉：测试一返回它就删，
|
|
// 协程此刻可能刚提交下一轮备份、正往目录里写新文件，RemoveAll 于是报
|
|
// 「unlinkat .../002: directory not empty」（本用例历史上就是这样偶发红的）。
|
|
// 清理按后进先出执行，这条比 t.TempDir 的清理注册得晚、所以先跑：
|
|
// 先取消 ctx 等协程真正停稳，t.TempDir 再去删就不会撞上还没落完的写。
|
|
t.Cleanup(func() {
|
|
cancel()
|
|
waitAutoBackupIdle(t, dir, interval)
|
|
})
|
|
|
|
NewService(nil, db, dir, 20, testLogger()).StartAuto(ctx, interval)
|
|
|
|
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(interval)
|
|
}
|
|
}
|
|
|
|
// waitAutoBackupIdle 等自动备份的后台协程停稳后再返回（供测试在删目录前调用）。
|
|
//
|
|
// Service.Wait 才是正式入口（StartAuto 起的协程都会被它 join，含已经在飞的那一轮备份）；
|
|
// 这里仍然从目录上观察「还在不在写」，因为这一条不依赖 Service 内部实现，
|
|
// 能把「Wait 返回了但目录还在变」这种回归直接照出来。协程的退出本身是确定的——
|
|
// 每轮 select 都先看 ctx.Done，ctx 一取消就返回，最多再走完一轮已经在飞的备份——
|
|
// 所以「连续若干个 tick 目录都没有新文件落盘」就足以判定它已经停了。
|
|
func waitAutoBackupIdle(t *testing.T, dir string, interval time.Duration) {
|
|
t.Helper()
|
|
|
|
// 20 个 tick 的安静窗口：远大于单轮备份（这份小库几毫秒）与调度抖动，
|
|
// 又短到不至于让用例等出可感知的慢。
|
|
const quietTicks = 20
|
|
quiet := quietTicks * interval
|
|
const patience = 5 * time.Second
|
|
|
|
deadline := time.Now().Add(patience)
|
|
last := backupDirState(t, dir)
|
|
quietSince := time.Now()
|
|
for {
|
|
time.Sleep(interval)
|
|
if cur := backupDirState(t, dir); cur != last {
|
|
last, quietSince = cur, time.Now()
|
|
}
|
|
if time.Since(quietSince) >= quiet {
|
|
return
|
|
}
|
|
if time.Now().After(deadline) {
|
|
// 非 Fatal：这里用 t.Errorf 是为了不打断后面的清理（Fatal 会跳过 t.TempDir 的清理，
|
|
// 反而把残留目录留在 TMPDIR 里），用例仍然会红。
|
|
t.Errorf("自动备份协程在 %s 内都没停稳，目录 %s 仍在变化", patience, dir)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// backupDirState 给备份目录拍一张快照，用来判断「还有没有新备份在落盘」。
|
|
// 快照带上文件名、大小与修改时间：同一秒内的第 2、3 份备份只是文件名多了序号，
|
|
// 靠修改时间也能把它们与前一份区分开。
|
|
func backupDirState(t *testing.T, dir string) string {
|
|
t.Helper()
|
|
|
|
entries, err := os.ReadDir(dir)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
return ""
|
|
}
|
|
t.Fatalf("读取备份目录 %s: %v", dir, err)
|
|
}
|
|
var b strings.Builder
|
|
for _, e := range entries {
|
|
info, err := e.Info()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
fmt.Fprintf(&b, "%s|%d|%d;", e.Name(), info.Size(), info.ModTime().UnixNano())
|
|
}
|
|
return b.String()
|
|
}
|
|
|
|
// 超过保留份数时删除最旧的备份。
|
|
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))
|
|
}
|