AskaEth
afef75f640
执行方案阶段 2 · P2-2（`DevDocs/audit/_plan.md`）。四条裁决： - 1.8/07.4.2：`think()` 不再走忽略 importance 的 `disturbAllowed`（已删），**接回 `Decide` 级联**； 安静时段只挡常规推送、**critical 安全域穿透**；`DecisionInput` 增 `ConclusionPush`/`Heartbeat`。 睡眠仍绝对不打扰（裁决只豁免安静时段，此点已在设计与报告写明）。 - 07.4.3：长静默（>2h）分支对**心跳类**放行（常规事件仍需 ≥high），刚聊过天 10min 内扣留不变。 - 07.4.4：`tickLoop` **启动立即先思考一轮** + 拟人化启动消息；启动轮与心跳**同门同限频** （重启风暴不会刷屏），ctx 已取消则跳过。 - 07.4.5：核对一致（`THINK_INTERVAL_SEC` 默认 900s 与 design/20 §0 权威口径一致）⇒ **代码零改动**。 验证：go build 绿；backthink 包 vet/测试绿；`-count=20`（抗 flake）+ `-race` 绿； linux/amd64 + darwin/arm64 交叉编译绿；gofmt 干净；文件 ≤500 行、无 >80 行函数。 变异验证（三条，均带还原证明）：① 安静时段改回"全拦" → 安全域穿透断言 FAIL（首次只删 critical 分支时仍绿——`critical >= high` 会从 high 分支漏过，故真实变异必须是"全拦"）； ② 删心跳豁免 → 长静默心跳断言 FAIL；③ 删启动思考 → 启动即思考断言 FAIL。 未验证：无真实模型凭据 ⇒ 启动轮问候与 `[我决定:…]` 解析仅经 mock + 真 loop 验证，端到端 LLM 未验。
233 lines
8.0 KiB
Go
233 lines
8.0 KiB
Go
package backthink
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// dayAt returns a mid-afternoon time in UTC (outside the quiet-hours window).
|
|
func dayAt() time.Time { return time.Date(2026, 9, 6, 14, 0, 0, 0, time.UTC) }
|
|
|
|
// nightAt returns a 02:00 time in UTC (inside the default 23-7 quiet window).
|
|
func nightAt() time.Time { return time.Date(2026, 9, 6, 2, 0, 0, 0, time.UTC) }
|
|
|
|
// testBackthink builds a Backthink with a normalized empty Config so Decide uses
|
|
// the default quiet-hours window (23:00-07:00).
|
|
func testBackthink() *Backthink {
|
|
return &Backthink{cfg: normalize(Config{})}
|
|
}
|
|
|
|
func TestDecide_DoNotDisturb(t *testing.T) {
|
|
t.Parallel()
|
|
b := testBackthink()
|
|
// 所有用例都带上她的结论要求推送（ConclusionPush），确保命中的是级联本身
|
|
// 而不是「结论不推」的短路。
|
|
cases := []struct {
|
|
name string
|
|
in DecisionInput
|
|
want bool
|
|
}{
|
|
{
|
|
name: "她的结论不推送_不推送",
|
|
in: DecisionInput{Trigger: "iot.device_update", Import: ImportanceCritical, At: dayAt(), UserState: UserState{}},
|
|
want: false,
|
|
},
|
|
{
|
|
name: "凌晨+睡眠_不打扰",
|
|
in: DecisionInput{Trigger: "iot.device_update", Import: ImportanceNormal, At: nightAt(), UserState: UserState{Sleeping: true}, ConclusionPush: true},
|
|
want: false,
|
|
},
|
|
{
|
|
name: "睡眠_危急也不打扰",
|
|
in: DecisionInput{Trigger: "system.event", Import: ImportanceCritical, At: dayAt(), UserState: UserState{Sleeping: true}, ConclusionPush: true},
|
|
want: false,
|
|
},
|
|
{
|
|
name: "上班_不打扰",
|
|
in: DecisionInput{Trigger: "iot.device_update", Import: ImportanceNormal, At: dayAt(), UserState: UserState{Working: true}, ConclusionPush: true},
|
|
want: false,
|
|
},
|
|
{
|
|
name: "忙碌_普通_不打扰",
|
|
in: DecisionInput{Trigger: "iot.device_update", Import: ImportanceNormal, At: dayAt(), UserState: UserState{Busy: true}, ConclusionPush: true},
|
|
want: false,
|
|
},
|
|
{
|
|
name: "安静时段_普通_不打扰",
|
|
in: DecisionInput{Trigger: "iot.device_update", Import: ImportanceNormal, At: nightAt(), UserState: UserState{Boredom: 0.9}, ConclusionPush: true},
|
|
want: false,
|
|
},
|
|
{
|
|
name: "安静时段_心跳_不打扰",
|
|
in: DecisionInput{Trigger: "heartbeat", Import: ImportanceLow, At: nightAt(), UserState: UserState{}, ConclusionPush: true, Heartbeat: true},
|
|
want: false,
|
|
},
|
|
}
|
|
for _, tc := range cases {
|
|
tc := tc
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
got := b.Decide(tc.in)
|
|
if got.ShouldPush != tc.want {
|
|
t.Fatalf("Decide(%+v).ShouldPush = %v, want %v (reason %q)", tc.in, got.ShouldPush, tc.want, got.Reason)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDecide_ShouldPush(t *testing.T) {
|
|
t.Parallel()
|
|
b := testBackthink()
|
|
cases := []struct {
|
|
name string
|
|
in DecisionInput
|
|
}{
|
|
{
|
|
name: "白天+重要_推",
|
|
in: DecisionInput{Trigger: "reminder.trigger", Import: ImportanceHigh, At: dayAt(), UserState: UserState{}, ConclusionPush: true},
|
|
},
|
|
{
|
|
name: "白天+危急_推",
|
|
in: DecisionInput{Trigger: "system.event", Import: ImportanceCritical, At: dayAt(), UserState: UserState{}, ConclusionPush: true},
|
|
},
|
|
{
|
|
name: "白天+普通+她的结论_推",
|
|
in: DecisionInput{Trigger: "iot.device_update", Import: ImportanceNormal, At: dayAt(), UserState: UserState{Boredom: 0.8}, ConclusionPush: true},
|
|
},
|
|
{
|
|
name: "安静时段+重要_推",
|
|
in: DecisionInput{Trigger: "reminder.trigger", Import: ImportanceHigh, At: nightAt(), UserState: UserState{}, ConclusionPush: true},
|
|
},
|
|
{
|
|
name: "安静时段+危急_安全域穿透_推",
|
|
in: DecisionInput{Trigger: "system.event", Import: ImportanceCritical, At: nightAt(), UserState: UserState{}, ConclusionPush: true},
|
|
},
|
|
{
|
|
name: "危急_可打断忙碌_推",
|
|
in: DecisionInput{Trigger: "system.event", Import: ImportanceCritical, At: dayAt(), UserState: UserState{Working: true}, ConclusionPush: true},
|
|
},
|
|
}
|
|
for _, tc := range cases {
|
|
tc := tc
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
got := b.Decide(tc.in)
|
|
if !got.ShouldPush {
|
|
t.Fatalf("Decide(%+v).ShouldPush = false, want true (reason %q)", tc.in, got.Reason)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestInQuietHours(t *testing.T) {
|
|
t.Parallel()
|
|
b := &Backthink{cfg: Config{QuietStartHour: 23, QuietEndHour: 7}}
|
|
cases := []struct {
|
|
name string
|
|
at time.Time
|
|
want bool
|
|
}{
|
|
{name: "午夜", at: time.Date(2026, 9, 6, 0, 0, 0, 0, time.UTC), want: true},
|
|
{name: "凌晨两点", at: nightAt(), want: true},
|
|
{name: "早上七点_偏出", at: time.Date(2026, 9, 6, 7, 0, 0, 0, time.UTC), want: false},
|
|
{name: "傍晚", at: time.Date(2026, 9, 6, 18, 30, 0, 0, time.UTC), want: false},
|
|
{name: "深夜十一点", at: time.Date(2026, 9, 6, 23, 0, 0, 0, time.UTC), want: true},
|
|
}
|
|
for _, tc := range cases {
|
|
tc := tc
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
if got := b.inQuietHours(tc.at); got != tc.want {
|
|
t.Fatalf("inQuietHours(%v) = %v, want %v", tc.at, got, tc.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestClassifyPush verifies the proactive message body maps to the intended flavor
|
|
// (问候/提醒/分享/关心) so the frequency gate can limit each flavor separately.
|
|
func TestClassifyPush(t *testing.T) {
|
|
t.Parallel()
|
|
cases := []struct {
|
|
in string
|
|
want PushKind
|
|
}{
|
|
{in: "记得明天体检", want: KindReminder},
|
|
{in: "提醒你到点吃药了", want: KindReminder},
|
|
{in: "最近累不累，注意身体", want: KindCare},
|
|
{in: "想你了，照顾好自己", want: KindCare},
|
|
{in: "早安，昨晚睡得好吗", want: KindGreeting},
|
|
{in: "晚上早点睡，晚安", want: KindGreeting},
|
|
{in: "发现一个有意思的地方，分享给你", want: KindShare},
|
|
{in: "跟往常一样没什么特别", want: KindCare}, // no keyword → generic fallback
|
|
}
|
|
for _, tc := range cases {
|
|
if got := classifyPush(tc.in); got != tc.want {
|
|
t.Fatalf("classifyPush(%q) = %v, want %v", tc.in, got, tc.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestDecide_ActivityGate verifies the activity-aware soft gate: a fresh
|
|
// conversation holds trivia (unless critical), a long-idle owner is only woken by
|
|
// an important event — except a heartbeat pass, which is never held by a
|
|
// long-silent gap (裁决 07.4.3) — and the in-between band does not over-suppress.
|
|
func TestDecide_ActivityGate(t *testing.T) {
|
|
t.Parallel()
|
|
b := testBackthink()
|
|
|
|
// Just chatted (within RecentChatCooldown=10min): a normal daytime push is
|
|
// held unless the event is safety-critical.
|
|
fresh := DecisionInput{
|
|
Import: ImportanceNormal,
|
|
At: dayAt(),
|
|
UserState: UserState{Boredom: 0.9},
|
|
LastActivity: dayAt().Add(-5 * time.Minute),
|
|
HasActivity: true,
|
|
ConclusionPush: true,
|
|
}
|
|
if got := b.Decide(fresh); got.ShouldPush {
|
|
t.Fatalf("fresh conversation should hold a normal push, got %+v", got)
|
|
}
|
|
fresh.Import = ImportanceCritical
|
|
if got := b.Decide(fresh); !got.ShouldPush {
|
|
t.Fatalf("critical event should push even in a fresh conversation, got %+v", got)
|
|
}
|
|
|
|
// Away a long while (> longIdleThreshold): only an important event is worth
|
|
// it — but a heartbeat pass still goes through (裁决 07.4.3 长期静默段不拦心跳).
|
|
idle := DecisionInput{
|
|
Import: ImportanceNormal,
|
|
At: dayAt(),
|
|
UserState: UserState{Boredom: 0.9},
|
|
LastActivity: dayAt().Add(-3 * time.Hour),
|
|
HasActivity: true,
|
|
ConclusionPush: true,
|
|
}
|
|
if got := b.Decide(idle); got.ShouldPush {
|
|
t.Fatalf("long idle should hold a normal event push, got %+v", got)
|
|
}
|
|
idle.Import = ImportanceHigh
|
|
if got := b.Decide(idle); !got.ShouldPush {
|
|
t.Fatalf("long idle high-importance should push, got %+v", got)
|
|
}
|
|
idle.Import = ImportanceLow
|
|
idle.Heartbeat = true
|
|
if got := b.Decide(idle); !got.ShouldPush {
|
|
t.Fatalf("long idle heartbeat should still push (07.4.3), got %+v", got)
|
|
}
|
|
|
|
// Middling activity (30 min ago) is not over-suppressed.
|
|
middle := DecisionInput{
|
|
Import: ImportanceNormal,
|
|
At: dayAt(),
|
|
UserState: UserState{Boredom: 0.9},
|
|
LastActivity: dayAt().Add(-30 * time.Minute),
|
|
HasActivity: true,
|
|
ConclusionPush: true,
|
|
}
|
|
if got := b.Decide(middle); !got.ShouldPush {
|
|
t.Fatalf("middle-band activity should allow a normal push, got %+v", got)
|
|
}
|
|
}
|