AskaEth
631c8dd8e1
用户给出的 8 条功能 + 一条口径变更，全部带真机/真浏览器验证：
① 录入页姓名后直接显示号码布（原「号码」列保留）
② 录入页批次进度条：`第 2 批 已录 5/8 · 3 条有错`，录完变绿；已录判据复用
entryGuards.judgeEntryRow（与发布防呆同源，不会出现"进度条说录完、发布说缺 8 条"）
⑦ 小项列表双击 → 跳到该小项的组别（编辑/删除按钮不误触）
③ 赛事开关 `standings.live_on_publish`（默认开＝保持原行为）：关闭后分批发布只上屏成绩，
名次/流水/榜单一起等该组录完再结算 —— 代理实读代码后纠正了我的前提：
奖牌榜读的是 results.rank（buildRanked）而非流水汇总，只延迟流水会出现
「有金牌但 0 分」。另提供 POST /api/results/settle 人工兜底 + GET /api/results/settlement 未结算清单
④ 组别「就地更新」PUT /api/events/{id}/categories/{categoryId}：有报名数据时也能改名/改年龄/
改性别/改权重（旧路径是整表替换，一改就被 409 拦下）；改名不动报名/成绩/流水（真机逐字节比对）；
权重真的变了才触发该组重算（容差 1e-9）
④辅 运动员列表多选+全选，POST /api/athletes/batch 一次请求完成整批停用/彻底删除（逐条回报，
dryRun 预览走同一段 SQL 但不提交、不写审计）——这才是绕开限流的正解
新增 报名项批量：POST /api/entries/batch（scratch/restore/remove）。退赛只动 registered、
跳过 dq/dns 并说明原因；移出是物理删除，必须显式清 score_ledger（该表 entry_id 是
ON DELETE SET NULL，不显式删会留下"人没了分还在"的孤儿流水，验证基线 orphan=0）；
退赛同时清 results.rank（否则出现"0 分还挂着金牌"）
⑤ GET /api/export/entries.xlsx 报名名单导出（13 列含批次，状态中文与录入页逐字一致）
⑥ 基础数据包：GET /api/export/basedata.xlsx + POST /api/export/basedata/import
（四张表、表头只有一份定义、表头行自动定位、列缺席≠写空、按编码 upsert、绝不删除、
行级中文错误带真实 Excel 行号、枚举走既有校验、新增单位一定是启用）
⑧ 登录有效期面板可配：系统设置新页签，1–720 小时，默认 12h → 24h；滑动续期 +
Cookie 同步刷新（只服务端续期是假的，浏览器侧的 Max-Age 到点仍会丢 Cookie）
身份口径：号码布为唯一标识、证件号退出匹配（号码布不同=同名的两个人，新建并单独报告）；
同一份表重复证件号不再报错；两个不同的人共用证件号仍报行级错误（唯一索引保留）
其它对齐：分项成绩表草稿行不再消失（成绩列「分数未录入」、名次/积分 `—`，没成绩的行同占位）；
大屏实时赛况单栏铺满（留白 370→78px）、字号上限 56→96px、≥7 行自动拆左右两块；
删除报名项/退赛/权重等改动都会重算并推榜单。
测试：服务端 13 包（连跑两遍）、前端 335 例、vue-tsc + build、Console 18 文件 —— 全绿。
文档：README、docs/ 四份（含 debug/使用说明 副本）、devdocs 05/08/04/13。
版本号 dev_0.1.5 → dev_0.1.6。
467 lines
18 KiB
Go
467 lines
18 KiB
Go
package httpapi_test
|
|
|
|
import (
|
|
"database/sql"
|
|
"fmt"
|
|
"net/http"
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
// setLiveOnPublish 直接改赛事库设置，等价于管理端 PUT /api/settings。
|
|
// 走库而不是接口是为了让用例只关心结算行为，设置写入由 TestLiveOnPublishSwitchPersists 单独覆盖。
|
|
func setLiveOnPublish(t *testing.T, env *testEnv, value bool) {
|
|
t.Helper()
|
|
env.exec(t, `INSERT INTO settings (key, value, updated_at) VALUES ('standings.live_on_publish', ?, datetime('now'))
|
|
ON CONFLICT(key) DO UPDATE SET value = excluded.value`, map[bool]string{true: "true", false: "false"}[value])
|
|
}
|
|
|
|
type settlementStatus struct {
|
|
LiveOnPublish bool `json:"liveOnPublish"`
|
|
Groups []struct {
|
|
EventID int64 `json:"eventId"`
|
|
CategoryID int64 `json:"categoryId"`
|
|
CategoryName string `json:"categoryName"`
|
|
Required int `json:"required"`
|
|
Published int `json:"published"`
|
|
} `json:"groups"`
|
|
}
|
|
|
|
func readSettlement(t *testing.T, env *testEnv, client *http.Client, eventID, categoryID int64) settlementStatus {
|
|
t.Helper()
|
|
status, resp := env.do(client, http.MethodGet,
|
|
fmt.Sprintf("/api/results/settlement?eventId=%d&categoryId=%d", eventID, categoryID), nil, false)
|
|
if status != http.StatusOK || !resp.OK {
|
|
t.Fatalf("读结算状态应 200，得到 %d %+v", status, resp.Error)
|
|
}
|
|
return decodeData[settlementStatus](t, resp)
|
|
}
|
|
|
|
func activeLedgerRows(t *testing.T, env *testEnv, eventID int64) int {
|
|
t.Helper()
|
|
var n int
|
|
if err := env.ev.QueryRow(
|
|
`SELECT COUNT(*) FROM score_ledger WHERE event_id = ? AND voided = 0`, eventID).Scan(&n); err != nil {
|
|
t.Fatalf("统计流水: %v", err)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func standingsTotal(t *testing.T, env *testEnv, client *http.Client) float64 {
|
|
t.Helper()
|
|
_, resp := env.do(client, http.MethodGet, "/api/standings", nil, false)
|
|
rows := decodeData[[]map[string]any](t, resp)
|
|
var total float64
|
|
for _, row := range rows {
|
|
total += row["totalPoints"].(float64)
|
|
}
|
|
return total
|
|
}
|
|
|
|
// rankOrZero 读名次：未发布的成绩没有名次（NULL），这里折算成 0，方便分批快照比较。
|
|
func rankOrZero(t *testing.T, env *testEnv, entryID int64) int {
|
|
t.Helper()
|
|
var rank sql.NullInt64
|
|
if err := env.ev.QueryRow(`SELECT rank FROM results WHERE entry_id = ?`, entryID).Scan(&rank); err != nil {
|
|
t.Fatalf("读取名次: %v", err)
|
|
}
|
|
if !rank.Valid {
|
|
return 0
|
|
}
|
|
return int(rank.Int64)
|
|
}
|
|
|
|
func changeLogCountOf(t *testing.T, env *testEnv, entityType string) int {
|
|
t.Helper()
|
|
var n int
|
|
if err := env.ev.QueryRow(`SELECT COUNT(*) FROM change_log WHERE entity_type = ?`, entityType).Scan(&n); err != nil {
|
|
t.Fatalf("统计 change_log: %v", err)
|
|
}
|
|
return n
|
|
}
|
|
|
|
// 默认（设置键不存在）必须是历史行为：分批发一批，流水与榜当场就变。
|
|
func TestLiveOnPublishDefaultIsRealTime(t *testing.T) {
|
|
env := newTestEnv(t)
|
|
ids := env.seed(t)
|
|
entries := seedBatch(t, env, ids, 8)
|
|
env.createUser("recorder", "recorder-pass", "recorder")
|
|
client, _ := env.client()
|
|
env.login(client, "recorder", "recorder-pass")
|
|
|
|
times := make([]float64, 8)
|
|
for i := range times {
|
|
times[i] = 12.0 + float64(i)*0.1
|
|
}
|
|
env.do(client, http.MethodPut, "/api/results/draft", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category, "results": batchDraft(entries, 4, 0, times),
|
|
}, true)
|
|
status, resp := env.do(client, http.MethodPost, "/api/results/publish", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category,
|
|
}, true)
|
|
if status != http.StatusOK || !resp.OK {
|
|
t.Fatalf("发布应 200，得到 %d %+v", status, resp.Error)
|
|
}
|
|
|
|
// 4 条已发布 = 4 条流水；前四名 10+8+6+3 = 27 分上榜。
|
|
assertCount(t, env, `SELECT COUNT(*) FROM score_ledger WHERE event_id = ? AND voided = 0`, 4, ids.event)
|
|
if got := standingsTotal(t, env, client); got != 27 {
|
|
t.Fatalf("默认设置下发布一批后榜单总分 = %v，期望 27", got)
|
|
}
|
|
if got := changeLogCountOf(t, env, "standings"); got != 1 {
|
|
t.Fatalf("默认设置下发布应推 1 次榜单，得到 %d", got)
|
|
}
|
|
if got := rankOfEntry(t, env, entries[0]); got != 1 {
|
|
t.Fatalf("第一名应第 1 名，得到 %d", got)
|
|
}
|
|
}
|
|
|
|
// 开关默认（键不存在）与显式 true 必须逐字节一致：
|
|
// 这是「加开关不能悄悄改变现场既有行为」的证明。
|
|
func TestLiveOnPublishDefaultMatchesExplicitTrue(t *testing.T) {
|
|
// snapshot 是一次发布之后的可比状态：名次、流水、榜单原始字节、榜单推送次数。
|
|
type snapshot struct {
|
|
ranks []int
|
|
ledger []string
|
|
standings string
|
|
pushes int
|
|
}
|
|
run := func(t *testing.T, value *bool) (afterFirst, afterSecond snapshot) {
|
|
t.Helper()
|
|
env := newTestEnv(t)
|
|
ids := env.seed(t)
|
|
entries := seedBatch(t, env, ids, 8)
|
|
if value != nil {
|
|
setLiveOnPublish(t, env, *value)
|
|
}
|
|
env.createUser("recorder", "recorder-pass", "recorder")
|
|
client, _ := env.client()
|
|
env.login(client, "recorder", "recorder-pass")
|
|
|
|
read := func() snapshot {
|
|
t.Helper()
|
|
var snap snapshot
|
|
for _, id := range entries {
|
|
snap.ranks = append(snap.ranks, rankOrZero(t, env, id))
|
|
}
|
|
rows, err := env.ev.Query(
|
|
`SELECT entry_id, team_id, points FROM score_ledger WHERE event_id = ? AND voided = 0 ORDER BY entry_id, team_id`, ids.event)
|
|
if err != nil {
|
|
t.Fatalf("读流水: %v", err)
|
|
}
|
|
defer func() { _ = rows.Close() }()
|
|
for rows.Next() {
|
|
var entryID, teamID int64
|
|
var points float64
|
|
if err := rows.Scan(&entryID, &teamID, &points); err != nil {
|
|
t.Fatalf("扫描流水: %v", err)
|
|
}
|
|
snap.ledger = append(snap.ledger, fmt.Sprintf("%d/%d/%v", entryID, teamID, points))
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
t.Fatalf("遍历流水: %v", err)
|
|
}
|
|
snap.standings = rawData(t, env, client, "/api/standings")
|
|
snap.pushes = changeLogCountOf(t, env, "standings")
|
|
return snap
|
|
}
|
|
|
|
slow := make([]float64, 8)
|
|
fast := make([]float64, 8)
|
|
for i := range slow {
|
|
slow[i] = 12.0 + float64(i)*0.1
|
|
fast[i] = 10.0 + float64(i)*0.1
|
|
}
|
|
env.do(client, http.MethodPut, "/api/results/draft", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category, "results": batchDraft(entries, 4, 0, slow),
|
|
}, true)
|
|
env.do(client, http.MethodPost, "/api/results/publish", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category,
|
|
}, true)
|
|
afterFirst = read()
|
|
|
|
env.do(client, http.MethodPut, "/api/results/draft", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category, "results": batchDraft(entries, 8, 4, fast),
|
|
}, true)
|
|
env.do(client, http.MethodPost, "/api/results/publish", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category,
|
|
}, true)
|
|
afterSecond = read()
|
|
return afterFirst, afterSecond
|
|
}
|
|
|
|
assertSame := func(t *testing.T, label string, absent, explicit snapshot) {
|
|
t.Helper()
|
|
if !reflect.DeepEqual(absent.ranks, explicit.ranks) {
|
|
t.Fatalf("%s：名次不一致：默认 %v vs 显式 true %v", label, absent.ranks, explicit.ranks)
|
|
}
|
|
if !reflect.DeepEqual(absent.ledger, explicit.ledger) {
|
|
t.Fatalf("%s：流水不一致：默认 %v vs 显式 true %v", label, absent.ledger, explicit.ledger)
|
|
}
|
|
if absent.standings != explicit.standings {
|
|
t.Fatalf("%s：榜单字节不一致：\n默认 %s\n显式 %s", label, absent.standings, explicit.standings)
|
|
}
|
|
if absent.pushes != explicit.pushes {
|
|
t.Fatalf("%s：榜单推送次数不一致：默认 %d vs 显式 true %d", label, absent.pushes, explicit.pushes)
|
|
}
|
|
}
|
|
|
|
absentFirst, absentSecond := run(t, nil)
|
|
explicit := true
|
|
trueFirst, trueSecond := run(t, &explicit)
|
|
assertSame(t, "第一批", absentFirst, trueFirst)
|
|
assertSame(t, "第二批", absentSecond, trueSecond)
|
|
|
|
// 反向证明这份快照确实受开关控制，否则上面的「一致」可能只是两条路径都坏了。
|
|
// 关掉开关后第一批只发 4/8：名次照写（延迟结算只省流水与榜单），流水必须为空、榜单必须不动。
|
|
off := false
|
|
offFirst, _ := run(t, &off)
|
|
if len(offFirst.ledger) != 0 {
|
|
t.Fatalf("关闭开关后第一批不该写流水，得到 %v", offFirst.ledger)
|
|
}
|
|
if offFirst.pushes != 0 {
|
|
t.Fatalf("关闭开关后第一批不该推榜单，得到 %d 次", offFirst.pushes)
|
|
}
|
|
if offFirst.standings == absentFirst.standings {
|
|
t.Fatalf("关闭开关后榜单应与默认不同，得到同一份：%s", offFirst.standings)
|
|
}
|
|
}
|
|
|
|
// 延迟结算：第一批只落成绩，名次 / 流水 / 榜单都不动；
|
|
// 第二批录完自动结算，整组重算并把名次与榜单补上。
|
|
func TestDeferredSettlementWaitsForWholeGroup(t *testing.T) {
|
|
env := newTestEnv(t)
|
|
ids := env.seed(t)
|
|
entries := seedBatch(t, env, ids, 8)
|
|
setLiveOnPublish(t, env, false)
|
|
env.createUser("recorder", "recorder-pass", "recorder")
|
|
client, _ := env.client()
|
|
env.login(client, "recorder", "recorder-pass")
|
|
|
|
slow := make([]float64, 8)
|
|
fast := make([]float64, 8)
|
|
for i := range slow {
|
|
slow[i] = 12.0 + float64(i)*0.1
|
|
fast[i] = 10.0 + float64(i)*0.1
|
|
}
|
|
// 发布之前的榜单原始字节：延迟结算下这批发布不允许改动它（含奖牌列）。
|
|
beforeStandings := rawData(t, env, client, "/api/standings")
|
|
|
|
env.do(client, http.MethodPut, "/api/results/draft", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category, "results": batchDraft(entries, 4, 0, slow),
|
|
}, true)
|
|
if status, e := env.do(client, http.MethodPost, "/api/results/publish", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category,
|
|
}, true); status != http.StatusOK || !e.OK {
|
|
t.Fatalf("第一批发布应 200，得到 %d %+v", status, e.Error)
|
|
}
|
|
|
|
// 成绩要上屏（可以看到时间），但名次 / 流水 / 榜单都要等结算。
|
|
assertCount(t, env, `SELECT COUNT(*) FROM results WHERE event_id = ? AND state = 'published'`, 4, ids.event)
|
|
assertCount(t, env, `SELECT COUNT(*) FROM score_ledger WHERE event_id = ? AND voided = 0`, 0, ids.event)
|
|
assertCount(t, env, `SELECT COUNT(*) FROM change_log WHERE entity_type = 'standings'`, 0)
|
|
// 名次不写：奖牌榜统计读的就是 results.rank，分批写名次会让奖牌列跟总分对不上。
|
|
assertCount(t, env, `SELECT COUNT(*) FROM results WHERE event_id = ? AND rank IS NOT NULL`, 0, ids.event)
|
|
if got := rawData(t, env, client, "/api/standings"); got != beforeStandings {
|
|
t.Fatalf("延迟结算下榜单不该动：\n发布前 %s\n发布后 %s", beforeStandings, got)
|
|
}
|
|
|
|
// 未结算清单要能查到这一组。
|
|
first := readSettlement(t, env, client, ids.event, ids.category)
|
|
if first.LiveOnPublish {
|
|
t.Fatalf("设置已关闭，接口应回报 liveOnPublish=false: %+v", first)
|
|
}
|
|
if len(first.Groups) != 1 || first.Groups[0].Required != 8 || first.Groups[0].Published != 4 {
|
|
t.Fatalf("未结算清单应含 4/8 的该组，得到 %+v", first.Groups)
|
|
}
|
|
|
|
// 第二批录完 → 自动结算：整组重算，流水齐全，榜单正确。
|
|
env.do(client, http.MethodPut, "/api/results/draft", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category, "results": batchDraft(entries, 8, 4, fast),
|
|
}, true)
|
|
if status, e := env.do(client, http.MethodPost, "/api/results/publish", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category,
|
|
}, true); status != http.StatusOK || !e.OK {
|
|
t.Fatalf("第二批发布应 200，得到 %d %+v", status, e.Error)
|
|
}
|
|
|
|
assertCount(t, env, `SELECT COUNT(*) FROM results WHERE event_id = ? AND state = 'published'`, 8, ids.event)
|
|
// 前六名得分 10+8+6+3+2+1 = 30，共 6 条流水。
|
|
assertCount(t, env, `SELECT COUNT(*) FROM score_ledger WHERE event_id = ? AND voided = 0`, 6, ids.event)
|
|
if got := standingsTotal(t, env, client); got != 30 {
|
|
t.Fatalf("结算后榜单总分 = %v，期望 30", got)
|
|
}
|
|
if got := changeLogCountOf(t, env, "standings"); got != 1 {
|
|
t.Fatalf("结算应推 1 次榜单，得到 %d", got)
|
|
}
|
|
// 整组重算的证明：第二批更快，第一批第一名退到第 5 名。
|
|
if got := rankOfEntry(t, env, entries[4]); got != 1 {
|
|
t.Fatalf("第二批最快者应第 1 名，得到 %d", got)
|
|
}
|
|
if got := rankOfEntry(t, env, entries[0]); got != 5 {
|
|
t.Fatalf("第一批第一名应退到第 5 名，得到 %d", got)
|
|
}
|
|
if got := readSettlement(t, env, client, ids.event, ids.category); len(got.Groups) != 0 {
|
|
t.Fatalf("结算后未结算清单应为空，得到 %+v", got.Groups)
|
|
}
|
|
}
|
|
|
|
// 有人弃权（scratched）时不该再等他：7 人录完 + 1 人退赛也算全组录完，自动结算。
|
|
func TestDeferredSettlementTreatsScratchedAsFinished(t *testing.T) {
|
|
env := newTestEnv(t)
|
|
ids := env.seed(t)
|
|
entries := seedBatch(t, env, ids, 8)
|
|
setLiveOnPublish(t, env, false)
|
|
env.createUser("recorder", "recorder-pass", "recorder")
|
|
client, _ := env.client()
|
|
env.login(client, "recorder", "recorder-pass")
|
|
|
|
// 第 8 人退赛（与前端「批量退赛」同一条接口）。
|
|
if status, e := env.do(client, http.MethodPost, "/api/entries/batch", map[string]any{
|
|
"action": "scratch", "ids": []int64{entries[7]},
|
|
}, true); status != http.StatusOK || !e.OK {
|
|
t.Fatalf("批量退赛应 200，得到 %d %+v", status, e.Error)
|
|
}
|
|
|
|
times := make([]float64, 8)
|
|
for i := range times {
|
|
times[i] = 12.0 + float64(i)*0.1
|
|
}
|
|
env.do(client, http.MethodPut, "/api/results/draft", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category, "results": batchDraft(entries, 7, 0, times),
|
|
}, true)
|
|
if status, e := env.do(client, http.MethodPost, "/api/results/publish", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category,
|
|
}, true); status != http.StatusOK || !e.OK {
|
|
t.Fatalf("发布应 200，得到 %d %+v", status, e.Error)
|
|
}
|
|
|
|
assertCount(t, env, `SELECT COUNT(*) FROM score_ledger WHERE event_id = ? AND voided = 0`, 6, ids.event)
|
|
if got := standingsTotal(t, env, client); got != 30 {
|
|
t.Fatalf("退赛者不该阻塞结算，榜单总分 = %v，期望 30", got)
|
|
}
|
|
if got := readSettlement(t, env, client, ids.event, ids.category); len(got.Groups) != 0 {
|
|
t.Fatalf("全组（含退赛）录完后清单应为空，得到 %+v", got.Groups)
|
|
}
|
|
}
|
|
|
|
// 发布之后才标退赛：整组因此录完，退赛动作本身也要把这组结算掉，不能停在空流水上。
|
|
func TestScratchAfterDeferredPublishSettlesGroup(t *testing.T) {
|
|
env := newTestEnv(t)
|
|
ids := env.seed(t)
|
|
entries := seedBatch(t, env, ids, 8)
|
|
setLiveOnPublish(t, env, false)
|
|
env.createUser("recorder", "recorder-pass", "recorder")
|
|
client, _ := env.client()
|
|
env.login(client, "recorder", "recorder-pass")
|
|
|
|
times := make([]float64, 8)
|
|
for i := range times {
|
|
times[i] = 12.0 + float64(i)*0.1
|
|
}
|
|
env.do(client, http.MethodPut, "/api/results/draft", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category, "results": batchDraft(entries, 7, 0, times),
|
|
}, true)
|
|
env.do(client, http.MethodPost, "/api/results/publish", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category,
|
|
}, true)
|
|
assertCount(t, env, `SELECT COUNT(*) FROM score_ledger WHERE event_id = ? AND voided = 0`, 0, ids.event)
|
|
|
|
if status, e := env.do(client, http.MethodPost, "/api/entries/batch", map[string]any{
|
|
"action": "scratch", "ids": []int64{entries[7]},
|
|
}, true); status != http.StatusOK || !e.OK {
|
|
t.Fatalf("批量退赛应 200，得到 %d %+v", status, e.Error)
|
|
}
|
|
|
|
assertCount(t, env, `SELECT COUNT(*) FROM score_ledger WHERE event_id = ? AND voided = 0`, 6, ids.event)
|
|
if got := standingsTotal(t, env, client); got != 30 {
|
|
t.Fatalf("退赛补全整组后应结算，榜单总分 = %v，期望 30", got)
|
|
}
|
|
}
|
|
|
|
// 立即结算是延迟结算的人工兜底：按当前已发布成绩结算，并写审计。
|
|
func TestManualSettleUsesPublishedResults(t *testing.T) {
|
|
env := newTestEnv(t)
|
|
ids := env.seed(t)
|
|
entries := seedBatch(t, env, ids, 8)
|
|
setLiveOnPublish(t, env, false)
|
|
env.createUser("recorder", "recorder-pass", "recorder")
|
|
client, _ := env.client()
|
|
env.login(client, "recorder", "recorder-pass")
|
|
|
|
times := make([]float64, 8)
|
|
for i := range times {
|
|
times[i] = 12.0 + float64(i)*0.1
|
|
}
|
|
env.do(client, http.MethodPut, "/api/results/draft", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category, "results": batchDraft(entries, 4, 0, times),
|
|
}, true)
|
|
env.do(client, http.MethodPost, "/api/results/publish", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category,
|
|
}, true)
|
|
|
|
if status, e := env.do(client, http.MethodPost, "/api/results/settle", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category, "requestId": "settle-1",
|
|
}, true); status != http.StatusOK || !e.OK {
|
|
t.Fatalf("立即结算应 200，得到 %d %+v", status, e.Error)
|
|
}
|
|
|
|
// 只有 4 条已发布 → 前四名 10+8+6+3 = 27 分。
|
|
assertCount(t, env, `SELECT COUNT(*) FROM score_ledger WHERE event_id = ? AND voided = 0`, 4, ids.event)
|
|
if got := standingsTotal(t, env, client); got != 27 {
|
|
t.Fatalf("立即结算后榜单总分 = %v，期望 27", got)
|
|
}
|
|
waitAudit(t, env, "result.settle", ids.event)
|
|
|
|
// 未登录不能结算。
|
|
guest, _ := env.client()
|
|
if status, _ := env.do(guest, http.MethodPost, "/api/results/settle", map[string]any{
|
|
"eventId": ids.event, "categoryId": ids.category,
|
|
}, false); status != http.StatusUnauthorized {
|
|
t.Fatalf("未登录结算应 401，得到 %d", status)
|
|
}
|
|
}
|
|
|
|
// 开关键写入 / 读出：PUT /api/settings 落库后 GET 要能读回，且缺键默认 true。
|
|
func TestLiveOnPublishSwitchPersists(t *testing.T) {
|
|
env := newTestEnv(t)
|
|
env.seed(t)
|
|
env.createUser("admin", "admin-pass", "admin")
|
|
client, _ := env.client()
|
|
env.login(client, "admin", "admin-pass")
|
|
|
|
read := func() bool {
|
|
t.Helper()
|
|
_, resp := env.do(client, http.MethodGet, "/api/settings", nil, false)
|
|
settings := decodeData[map[string]any](t, resp)
|
|
return settings["standings"].(map[string]any)["liveOnPublish"].(bool)
|
|
}
|
|
if !read() {
|
|
t.Fatalf("缺键时 liveOnPublish 应默认 true")
|
|
}
|
|
|
|
if status, e := env.do(client, http.MethodPut, "/api/settings", map[string]any{
|
|
"standings": map[string]any{"liveOnPublish": false},
|
|
}, true); status != http.StatusOK || !e.OK {
|
|
t.Fatalf("关闭开关应 200，得到 %d %+v", status, e.Error)
|
|
}
|
|
if read() {
|
|
t.Fatalf("关闭后 liveOnPublish 应读回 false")
|
|
}
|
|
// 只改一个字段不能把榜单口径的其余取值抹掉。
|
|
_, resp := env.do(client, http.MethodGet, "/api/settings", nil, false)
|
|
standings := decodeData[map[string]any](t, resp)["standings"].(map[string]any)
|
|
if standings["individualToTeamWeight"].(float64) != 1 || standings["rankingMode"] != "points" {
|
|
t.Fatalf("其余榜单口径不应被改动: %+v", standings)
|
|
}
|
|
|
|
if status, e := env.do(client, http.MethodPut, "/api/settings", map[string]any{
|
|
"standings": map[string]any{"liveOnPublish": true},
|
|
}, true); status != http.StatusOK || !e.OK {
|
|
t.Fatalf("重新打开应 200，得到 %d %+v", status, e.Error)
|
|
}
|
|
if !read() {
|
|
t.Fatalf("重新打开后 liveOnPublish 应读回 true")
|
|
}
|
|
}
|