Cyrene_v2/internal/runtime/memory/tidy_service_tuning_test.go

package memory

import (
	"sync"
	"testing"
	"time"

	"git.yeij.top/AskaEth/Cyrene_v2/internal/config/runtimeconfig"
)

// 本文件锁定**运行期调优**（切片 MEMPANEL / M4：面板保存 ⇒ 当场生效，
// 不要求重启后端）的两条判据：
//  ① 整理档：面板值按「面板 > `.env` > 代码默认」**重算**（不是叠在现值上）——
//     把键清掉（nil）必须回到 `base` 那一档，而不是留着上一次的面板值；心跳
//     在跑时保存会被**重排**（新周期立刻生效），没跑时是空操作。
//  ② 入库审查档：`ingestGate` / `tempTtlSec` 两个键同样重算（中档结构性为空 ⇒
//     清掉即回代码默认），且经 `Store.ApplyIngestPanelTuning` 转调可达。

// tuningInt 返回面板调优用的 *int。
func tuningInt(v int) *int { return &v }

// tuningBool 返回面板调优用的 *bool。
func tuningBool(v bool) *bool { return &v }

// TestTidyServiceApplyPanelTuning_RecomputesFromEnvBase 面板 > .env > 代码默认，
// 且**重算而不是叠加**：清掉一个键就回到 base 那一档。
func TestTidyServiceApplyPanelTuning_RecomputesFromEnvBase(t *testing.T) {
	t.Parallel()
	base := TidyConfig{Enabled: true, IntervalSec: 86400, QuietStartHour: 23, QuietEndHour: 7}
	svc := newTidyServiceForTest(t, newTestStore(t), base, nil, time.Now, nil)

	// 面板给了三个键 ⇒ 三个都按面板走，没给的键保持 base（.env）档。
	panel := runtimeconfig.MemoryTidyTuning{
		IntervalSec:      tuningInt(10800),
		QuietIntervalSec: tuningInt(36000),
		AutoApply:        tuningBool(false),
	}
	if err := svc.ApplyPanelTuning(base, panel); err != nil {
		t.Fatalf("ApplyPanelTuning: %v", err)
	}
	if svc.cfg.IntervalSec != 10800 || svc.cfg.Interval != 3*time.Hour {
		t.Fatalf("interval = %d / %s, want 10800 / 3h", svc.cfg.IntervalSec, svc.cfg.Interval)
	}
	if svc.cfg.QuietIntervalSec != 36000 || svc.cfg.QuietInterval != 10*time.Hour {
		t.Fatalf("quiet interval = %d / %s, want 36000 / 10h",
			svc.cfg.QuietIntervalSec, svc.cfg.QuietInterval)
	}
	if !svc.cfg.DisableAutoApply {
		t.Fatal("autoApply:false 应当落到 DisableAutoApply")
	}
	if svc.cfg.QuietStartHour != 23 || svc.cfg.QuietEndHour != 7 {
		t.Fatalf("没写 quietStartHour/quietEndHour 时应当保持 base：%+v", svc.cfg)
	}
	// 两个持有者都要写：调度读 s.cfg，每一轮读 tidier.cfg。
	if svc.tidier.cfg.IntervalSec != 10800 || !svc.tidier.cfg.DisableAutoApply {
		t.Fatalf("tidier 配置没跟上：%+v", svc.tidier.cfg)
	}

	// 🔴 清掉 intervalSec（模拟面板 null 清除）⇒ 必须回到 base 的 86400，
	// 而不是留在上一次的 10800。
	cleared := runtimeconfig.MemoryTidyTuning{QuietStartHour: tuningInt(1), QuietEndHour: tuningInt(5)}
	if err := svc.ApplyPanelTuning(base, cleared); err != nil {
		t.Fatalf("ApplyPanelTuning(cleared): %v", err)
	}
	if svc.cfg.IntervalSec != 86400 {
		t.Fatalf("清掉面板键后应回到 .env 档 86400，得到 %d（叠加而非重算）", svc.cfg.IntervalSec)
	}
	if svc.cfg.QuietIntervalSec != 86400 {
		t.Fatalf("清掉 quietIntervalSec 后应回到 intervalSec 档，得到 %d", svc.cfg.QuietIntervalSec)
	}
	if svc.cfg.DisableAutoApply {
		t.Fatal("清掉 autoApply 后应回到代码默认（开）")
	}
	if svc.cfg.QuietStartHour != 1 || svc.cfg.QuietEndHour != 5 {
		t.Fatalf("quietStartHour/quietEndHour 应当采用面板值：%+v", svc.cfg)
	}
}

// TestTidyServiceApplyPanelTuning_ReschedulesRunningHeartbeat 心跳在跑时保存 ⇒ 心跳
// 被重排（仍活着，且下一次等待按**新**周期算）。没跑时是空操作。
func TestTidyServiceApplyPanelTuning_ReschedulesRunningHeartbeat(t *testing.T) {
	t.Parallel()
	at := time.Date(2026, 10, 13, 15, 0, 0, 0, time.Local)
	base := TidyConfig{Enabled: true, IntervalSec: 86400, QuietStartHour: 23, QuietEndHour: 7}
	svc := newTidyServiceForTest(t, newTestStore(t), base, nil, fixedTidyClock(at), nil)

	// 未启动：保存只改配置，不碰心跳状态（用一个不含 intervalSec 的补丁，免得
	// 影响下面「旧周期」的断言）。
	idlePanel := runtimeconfig.MemoryTidyTuning{QuietStartHour: tuningInt(22), QuietEndHour: tuningInt(6)}
	if err := svc.ApplyPanelTuning(base, idlePanel); err != nil {
		t.Fatalf("ApplyPanelTuning(idle): %v", err)
	}
	svc.mu.Lock()
	running := svc.running
	svc.mu.Unlock()
	if running {
		t.Fatal("未 Start 时不该因为保存而启动心跳")
	}

	// 启动后：造出「上次跑过」的历史，于是下一拍 = 上次 + 当时时段的周期。
	// 15:00、上次 14:30、周期 24h ⇒ 下一拍还要等 23.5 小时（旧周期）。
	svc.Start(nil)
	t.Cleanup(func() { _ = svc.Stop(nil) })
	svc.mu.Lock()
	svc.lastRun = at.Add(-30 * time.Minute)
	svc.mu.Unlock()
	if got := svc.nextDelay(); got != 23*time.Hour+30*time.Minute {
		t.Fatalf("启动后 nextDelay = %s, want 23h30m（旧周期）", got)
	}
	// 把周期改短并**重排**：新的下一拍应当按 1 小时的周期算（= 上次 + 1h ⇒ 还有
	// 30 分钟），而不是继续睡原来那 23.5 小时。
	if err := svc.ApplyPanelTuning(base, runtimeconfig.MemoryTidyTuning{IntervalSec: tuningInt(3600)}); err != nil {
		t.Fatalf("ApplyPanelTuning(running): %v", err)
	}
	svc.mu.Lock()
	running = svc.running
	svc.mu.Unlock()
	if !running {
		t.Fatal("重排后心跳必须仍在跑（否则定时整理会悄悄停摆）")
	}
	if got := svc.nextDelay(); got != 30*time.Minute {
		t.Fatalf("重排后的 nextDelay = %s, want 30m（仍按旧周期说明没重排）", got)
	}
}

// TestTidyServiceApplyPanelTuning_UnchangedConfigKeepsHeartbeat 只改别的键（配置没变）
// 时不打扰心跳：那一次保存不该白白停一次心跳。
func TestTidyServiceApplyPanelTuning_UnchangedConfigKeepsHeartbeat(t *testing.T) {
	t.Parallel()
	at := time.Date(2026, 10, 13, 15, 0, 0, 0, time.Local)
	base := TidyConfig{Enabled: true, IntervalSec: 86400, QuietStartHour: 23, QuietEndHour: 7}
	svc := newTidyServiceForTest(t, newTestStore(t), base, nil, fixedTidyClock(at), nil)
	svc.Start(nil)
	t.Cleanup(func() { _ = svc.Stop(nil) })
	same := normalizeTidyConfig(base)
	if svc.cfg != same {
		t.Fatalf("前置条件不成立：%+v vs %+v", svc.cfg, same)
	}
	if err := svc.ApplyPanelTuning(base, runtimeconfig.MemoryTidyTuning{}); err != nil {
		t.Fatalf("ApplyPanelTuning(noop): %v", err)
	}
	if got := svc.nextDelay(); got != 8*time.Hour {
		t.Fatalf("配置没变时不该重排心跳（无历史时仍锚到低峰起点 8h）：nextDelay = %s", got)
	}
}

// TestPreInsertReviewerApplyPanelTuning_RecomputesIngestKeys 审查侧的两个键同样
// **重算**：清掉即回代码默认（中档结构性为空）。
func TestPreInsertReviewerApplyPanelTuning_RecomputesIngestKeys(t *testing.T) {
	t.Parallel()
	store := newTestStore(t)
	reviewer, err := NewPreInsertReviewer(ReviewConfig{Enabled: true}, ReviewDeps{Store: store, Log: testLogger()})
	if err != nil {
		t.Fatalf("NewPreInsertReviewer: %v", err)
	}
	// 面板关闸 + 1 小时 TTL。
	panel := runtimeconfig.MemoryTidyTuning{IngestGate: tuningBool(false), TempTtlSec: tuningInt(3600)}
	if err := reviewer.ApplyPanelTuning(panel); err != nil {
		t.Fatalf("ApplyPanelTuning: %v", err)
	}
	if !reviewer.cfg.DisableIngestGate {
		t.Fatal("ingestGate:false 应当当场关掉同步入库闸")
	}
	if reviewer.cfg.TempTTL != time.Hour {
		t.Fatalf("tempTtlSec 未生效：%s", reviewer.cfg.TempTTL)
	}
	// 闸的判定面也真的变了（gateEnabled 直接读这份 cfg）。
	if reviewer.gateEnabled() {
		t.Fatal("关闸后 gateEnabled 仍为 true")
	}
	// 清掉两个键 ⇒ 回到代码默认（闸开、TTL 7 天）。
	if err := reviewer.ApplyPanelTuning(runtimeconfig.MemoryTidyTuning{}); err != nil {
		t.Fatalf("ApplyPanelTuning(cleared): %v", err)
	}
	if reviewer.cfg.DisableIngestGate || !reviewer.gateEnabled() {
		t.Fatal("清掉 ingestGate 后应当回到默认（开）")
	}
	if want := time.Duration(tempTtlSec) * time.Second; reviewer.cfg.TempTTL != want {
		t.Fatalf("清掉 tempTtlSec 后 TTL = %s, want %s（代码默认）", reviewer.cfg.TempTTL, want)
	}
	// 坏值（0 秒）不得落进 cfg：回落代码默认，而不是「不过期」也不是「落库即过期」。
	if err := reviewer.ApplyPanelTuning(runtimeconfig.MemoryTidyTuning{TempTtlSec: tuningInt(0)}); err != nil {
		t.Fatalf("ApplyPanelTuning(bad ttl): %v", err)
	}
	if want := time.Duration(tempTtlSec) * time.Second; reviewer.cfg.TempTTL != want {
		t.Fatalf("坏 TTL 应当回落默认 %s，得到 %s", want, reviewer.cfg.TempTTL)
	}
	// 审查本身的其它旋钮**一个都不动**（它们不是面板键）。
	if !reviewer.cfg.Enabled || reviewer.cfg.QueueSize == 0 || reviewer.cfg.ScanLimit == 0 {
		t.Fatalf("面板调优误伤了别的旋钮：%+v", reviewer.cfg)
	}
}

// TestStoreApplyIngestPanelTuning_DelegatesToAttachedReviewer 网关只能通过记忆存储
// 触达审查侧（deps.Memories），因此这条转调就是那条通道：接了审查 ⇒ 转调生效；
// 没接（审查关闭）⇒ 空操作 + nil（那时两个键本来就不生效）。
func TestStoreApplyIngestPanelTuning_DelegatesToAttachedReviewer(t *testing.T) {
	t.Parallel()
	store := newTestStore(t)
	if err := store.ApplyIngestPanelTuning(runtimeconfig.MemoryTidyTuning{IngestGate: tuningBool(false)}); err != nil {
		t.Fatalf("未接审查时应当空操作 + nil，得到 %v", err)
	}
	reviewer, err := NewPreInsertReviewer(ReviewConfig{Enabled: true}, ReviewDeps{Store: store, Log: testLogger()})
	if err != nil {
		t.Fatalf("NewPreInsertReviewer: %v", err)
	}
	store.AttachIngestReviewer(reviewer)
	if err := store.ApplyIngestPanelTuning(runtimeconfig.MemoryTidyTuning{IngestGate: tuningBool(false)}); err != nil {
		t.Fatalf("Store.ApplyIngestPanelTuning: %v", err)
	}
	if !reviewer.cfg.DisableIngestGate {
		t.Fatal("经 Store 的转调没有落到审查服务上")
	}
}

// TestPreInsertReviewer_PanelTuningRaceWithGateReads 是**并发回归哨兵**（切片
// MEMPANEL / M4 的快修）。
//
// 背景：面板调优（`ApplyPanelTuning`）会在**运行期**改 `cfg` 的两个字段
// （`DisableIngestGate` / `TempTTL`）。在这条特性之前 `cfg` 是构造期冻结的，读侧
// 无锁本来安全；有了运行期写入之后，凡是读这两个字段的地方都必须与写方同步 ——
// 否则就是「写方持锁、读方不持锁」的数据竞争。读侧两处分别是：
//   - `gateEnabled()`（同步入库闸，记忆**写入路径**上调用）；
//   - `deferDeadline()`（第五态 `defer` 落 `expires_at`，写入路径与异步审查都会调）。
//
// 它**只在 `-race` 下有意义**：不带 `-race` 时它只是一次并发冒烟（两边都跑完即通过），
// 有没有竞争交给 race detector 判。跑法：
//
//	go test -race -count=1 -run TestPreInsertReviewer_PanelTuningRaceWithGateReads ./internal/runtime/memory/
func TestPreInsertReviewer_PanelTuningRaceWithGateReads(t *testing.T) {
	store := newTestStore(t)
	reviewer, err := NewPreInsertReviewer(ReviewConfig{Enabled: true}, ReviewDeps{Store: store, Log: testLogger()})
	if err != nil {
		t.Fatalf("NewPreInsertReviewer: %v", err)
	}
	const rounds = 200
	var wg sync.WaitGroup
	wg.Add(3)
	// 写方：模拟面板保存（每次改两个面板键）。
	go func() {
		defer wg.Done()
		for i := 0; i < rounds; i++ {
			panel := runtimeconfig.MemoryTidyTuning{
				IngestGate: tuningBool(i%2 == 0),
				TempTtlSec: tuningInt(3600 + i),
			}
			if err := reviewer.ApplyPanelTuning(panel); err != nil {
				t.Errorf("ApplyPanelTuning: %v", err)
				return
			}
		}
	}()
	// 读方一：同步入库闸的开关判定（写入路径）。
	go func() {
		defer wg.Done()
		for i := 0; i < rounds; i++ {
			_ = reviewer.gateEnabled()
		}
	}()
	// 读方二：第五态的到期时刻。
	go func() {
		defer wg.Done()
		for i := 0; i < rounds; i++ {
			_ = reviewer.deferDeadline(time.Now())
		}
	}()
	wg.Wait()
}

// TestTidyService_PanelTuningRaceWithLiveHeartbeat 是整理档的**并发回归哨兵**。
//
// 背景（实测踩出来的，不是推演）：`s.cfg` 的**调度读**（`nextDelay` / `dueNow`）
// 不持锁，因此「面板调优写 cfg」必须落在一个**没有任何 goroutine 读它**的窗口里。
// 曾经的顺序 `Stop → Start → 写` 在这里会被 -race 抓住：新起的循环立刻读 `s.cfg`
// 重算下一拍，与写入并排（而且那一拍还可能按**旧**配置算出来）。正确顺序是
// `Stop → 写 → Start`。
//
// 读者刻意**不**另起 goroutine 调 `nextDelay()`：那个入口在包里只有心跳 goroutine
// 会调（生产代码不在别处调它），另起一个就是伪造一个生产不存在的调用方。这里直接让
// **真心跳**当读者（连跑多轮，每轮都要停一次、起一次），与生产形态一致。
//
// 同样**只在 `-race` 下有意义**（不带 -race 时它是一次并发冒烟 + 值生效断言）。跑法：
//
//	go test -race -count=1 -run TestTidyService_PanelTuningRaceWithLiveHeartbeat ./internal/runtime/memory/
func TestTidyService_PanelTuningRaceWithLiveHeartbeat(t *testing.T) {
	at := time.Date(2026, 10, 13, 15, 0, 0, 0, time.Local)
	base := TidyConfig{Enabled: true, IntervalSec: 86400, QuietStartHour: 23, QuietEndHour: 7}
	svc := newTidyServiceForTest(t, newTestStore(t), base, nil, fixedTidyClock(at), nil)
	svc.Start(nil)
	t.Cleanup(func() { _ = svc.Stop(nil) })

	const rounds = 25
	for i := 0; i < rounds; i++ {
		panel := runtimeconfig.MemoryTidyTuning{IntervalSec: tuningInt(3600 + i)}
		if err := svc.ApplyPanelTuning(base, panel); err != nil {
			t.Fatalf("ApplyPanelTuning(%d): %v", i, err)
		}
	}
	// 每轮重排之后心跳都必须还活着（`Stop` 把 running 置为 false，忘了重启就会静默停摆），
	// 且最后一轮的周期真的生效在运行期。
	svc.mu.Lock()
	running := svc.running
	svc.mu.Unlock()
	if !running {
		t.Fatal("连着保存多次之后心跳必须仍在跑")
	}
	if want := 3600 + rounds - 1; svc.cfg.IntervalSec != want {
		t.Fatalf("最后一轮的 intervalSec = %d, want %d", svc.cfg.IntervalSec, want)
	}
}