File size: 5,787 Bytes
e48a2d8 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 | package scheduler
import (
"context"
"sort"
"testing"
"time"
"github.com/misakano7545/workbuddy2api-panel/internal/cst"
"github.com/misakano7545/workbuddy2api-panel/internal/pool"
)
// TestSpreadDeterministic 同一天同一任务同一批账号 → 偏移不变(重启不重排)。
func TestSpreadDeterministic(t *testing.T) {
uids := []string{"a", "b", "c", "d", "e", "f", "g", "h"}
now := time.Date(2026, 10, 21, 9, 0, 0, 0, cst.Loc)
first := newAccountSpread(taskCheckin, uids, 30*time.Minute, 0, now)
second := newAccountSpread(taskCheckin, uids, 30*time.Minute, 0, now)
if first == nil || second == nil {
t.Fatal("窗口 > 0 时应生成计划")
}
for _, uid := range uids {
if !first.at[uid].Equal(second.at[uid]) {
t.Fatalf("%s 偏移不稳定:%v vs %v", uid, first.at[uid], second.at[uid])
}
}
// 换一天应换一批偏移:日期没进哈希就会全同。
nextDay := now.AddDate(0, 0, 1)
other := newAccountSpread(taskCheckin, uids, 30*time.Minute, 0, nextDay)
same := 0
for _, uid := range uids {
if first.at[uid].Sub(now) == other.at[uid].Sub(nextDay) {
same++
}
}
if same == len(uids) {
t.Fatal("跨天偏移全部相同,日期没进哈希")
}
}
// TestSpreadRespectsMinGap 偏移撞车时靠后的被推开:同批任意相邻间隔 ≥ minGap,
// 且全部落在窗口内。
func TestSpreadRespectsMinGap(t *testing.T) {
uids := make([]string, 10)
for i := range uids {
uids[i] = string(rune('a' + i))
}
window, gap := 30*time.Minute, 90*time.Second
now := time.Date(2026, 10, 21, 9, 0, 0, 0, cst.Loc)
plan := newAccountSpread(taskTravel, uids, window, gap, now)
offs := make([]time.Duration, 0, len(uids))
for _, uid := range uids {
off := plan.at[uid].Sub(now)
if off < 0 || off >= window {
t.Fatalf("%s 偏移 %v 越出窗口 %v", uid, off, window)
}
offs = append(offs, off)
}
sort.Slice(offs, func(i, j int) bool { return offs[i] < offs[j] })
for i := 1; i < len(offs); i++ {
if d := offs[i] - offs[i-1]; d < gap {
t.Fatalf("排序后相邻间隔 %v < %v", d, gap)
}
}
}
// TestSpreadDisabled 窗口 <= 0 与空池不生成计划;nil 计划 / 计划外账号的 wait 立即放行。
func TestSpreadDisabled(t *testing.T) {
now := time.Date(2026, 10, 21, 9, 0, 0, 0, cst.Loc)
if plan := newAccountSpread(taskCheckin, []string{"a"}, 0, 0, now); plan != nil {
t.Fatal("窗口 0 应返回 nil")
}
if plan := newAccountSpread(taskCheckin, nil, time.Minute, 0, now); plan != nil {
t.Fatal("空池应返回 nil")
}
var plan *accountSpread
if !plan.wait(context.Background(), "a") {
t.Fatal("nil 计划应立即放行")
}
// 池在本轮中途新增的账号不在计划里:立即执行,不睡。
real := newAccountSpread(taskCheckin, []string{"a"}, time.Hour, 0, now)
if !real.wait(context.Background(), "newcomer") {
t.Fatal("计划外账号应立即放行")
}
}
// TestSpreadManualEntryNeverSpreads 面板手动触发不受摊开影响(否则一次点击要等半小时)。
func TestSpreadManualEntryNeverSpreads(t *testing.T) {
s := New(Config{AccountSpreadMinutes: 30, AccountSpreadMinGapSeconds: 60})
if plan := s.spreadPlan(taskCheckin, false, time.Now()); plan != nil {
t.Fatal("手动入口不应生成摊开计划")
}
if !s.spreadEnabled() {
t.Fatal("窗口 > 0 时 spreadEnabled 应为 true")
}
}
// TestSpreadOrderFollowsPlannedTime 遍历顺序必须按计划时刻升序:这样每个 wait 都是
// 最后一次,实际开始时刻 = 计划时刻。uid 序下若前面的账号计划时刻更晚,后面的会被
// 逐个堵住、最后挤在同一秒跑完(issue #45 实测:10 个账号塌缩成 2–3 个执行时刻)。
func TestSpreadOrderFollowsPlannedTime(t *testing.T) {
uids := make([]string, 10)
for i := range uids {
uids[i] = string(rune('a' + i))
}
now := time.Date(2026, 10, 22, 21, 0, 0, 0, cst.Loc)
plan := newAccountSpread(taskCheckin, uids, 45*time.Minute, 60*time.Second, now)
if plan == nil {
t.Fatal("窗口 > 0 时应生成计划")
}
list := make([]pool.Status, len(uids))
for i, uid := range uids {
list[i] = pool.Status{UID: uid}
}
cur := now
seen := make(map[string]bool, len(uids))
for _, st := range plan.order(list) {
if seen[st.UID] {
t.Fatalf("账号 %s 重复", st.UID)
}
seen[st.UID] = true
at := plan.at[st.UID]
if at.After(cur) {
cur = at
}
if !cur.Equal(at) {
t.Fatalf("账号 %s 在计划序下仍被前一账号推迟:计划 %v,实际 %v", st.UID, at, cur)
}
}
if len(seen) != len(uids) {
t.Fatalf("order 丢了账号:%d/%d", len(seen), len(uids))
}
}
// TestSpreadUIDOrderCollapses 回归证据:同一计划按 uid 序串行等待(修复前的行为)
// 会塌缩——不同执行时刻数明显少于账号数。钉住「问题真实存在」,防止有人把
// order() 改回 uid 序。
func TestSpreadUIDOrderCollapses(t *testing.T) {
uids := make([]string, 10)
for i := range uids {
uids[i] = string(rune('a' + i))
}
now := time.Date(2026, 10, 22, 21, 0, 0, 0, cst.Loc)
plan := newAccountSpread(taskCheckin, uids, 45*time.Minute, 60*time.Second, now)
cur := now
moments := make(map[time.Time]bool, len(uids))
for _, uid := range uids {
if at := plan.at[uid]; at.After(cur) {
cur = at
}
moments[cur] = true
}
if len(moments) >= len(uids) {
t.Fatalf("uid 序竟然没有塌缩(%d/%d),回归证据失效", len(moments), len(uids))
}
}
// TestSpreadOrderNilPassthrough nil 计划(未启用/手动触发)不重排。
func TestSpreadOrderNilPassthrough(t *testing.T) {
list := []pool.Status{{UID: "b"}, {UID: "a"}}
var plan *accountSpread
got := plan.order(list)
if len(got) != 2 || got[0].UID != "b" || got[1].UID != "a" {
t.Fatalf("nil 计划不应重排:%+v", got)
}
}
|