Cyrene_v2/internal/services/backthink/push_test.go

package backthink

import (
	"context"
	"testing"
	"time"

	"git.yeij.top/AskaEth/Cyrene_v2/internal/channel/adapter"
	"git.yeij.top/AskaEth/Cyrene_v2/internal/channel/session"
)

func TestPusher_AutoRoutesIM(t *testing.T) {
	t.Parallel()
	// The owner mandate: a default (auto) push reaches ONE channel over the IM
	// bridge (the bridge picks her [渠道:...] choice, then her most recent platform,
	// then the whitelist default) — not the active web client by default.
	active := &mockActive{n: 2} // a web client is online but is NOT the default target
	im := &mockIMAdapter{}
	p := newPusher(active, im, &mockGate{allow: true}, discardLog())

	res := p.Push(context.Background(), PushRequest{Message: adapter.UnifiedMessage{}})

	if !res.Pushed {
		t.Fatalf("Pushed = false, want true")
	}
	if res.Route != RouteIMBridge {
		t.Fatalf("Route = %q, want %q", res.Route, RouteIMBridge)
	}
	if im.count() != 1 {
		t.Fatalf("im calls = %d, want 1 (single IM target)", im.count())
	}
	if active.calls != 0 {
		t.Fatalf("active calls = %d, want 0 (web is not the default target)", active.calls)
	}
}

func TestPusher_WebHintRoutesActive(t *testing.T) {
	t.Parallel()
	active := &mockActive{n: 1}
	im := &mockIMAdapter{}
	p := newPusher(active, im, &mockGate{allow: true}, discardLog())

	res := p.Push(context.Background(), PushRequest{ChannelHint: channelWeb, Message: adapter.UnifiedMessage{}})

	if !res.Pushed {
		t.Fatalf("Pushed = false, want true")
	}
	if res.Route != RouteActiveClient {
		t.Fatalf("Route = %q, want %q", res.Route, RouteActiveClient)
	}
	if active.calls != 1 {
		t.Fatalf("active calls = %d, want 1", active.calls)
	}
	if im.count() != 0 {
		t.Fatalf("im calls = %d, want 0 (web hint targets only the active client)", im.count())
	}
}

func TestPusher_ConcreteHintRoutesIM_SingleTarget(t *testing.T) {
	t.Parallel()
	// A concrete decision channel is honored over the IM bridge, and exactly ONE
	// target is used (the IM bridge carries it; the active client is not touched).
	active := &mockActive{n: 2}
	im := &mockIMAdapter{}
	p := newPusher(active, im, &mockGate{allow: true}, discardLog())

	res := p.Push(context.Background(), PushRequest{ChannelHint: "kook", Message: adapter.UnifiedMessage{}})

	if !res.Pushed {
		t.Fatalf("Pushed = false, want true")
	}
	if res.Route != RouteIMBridge {
		t.Fatalf("Route = %q, want %q", res.Route, RouteIMBridge)
	}
	if im.count() != 1 {
		t.Fatalf("im calls = %d, want 1", im.count())
	}
	if active.calls != 0 {
		t.Fatalf("active calls = %d, want 0 (a concrete hint targets only the IM bridge)", active.calls)
	}
	if im.last.Platform != "kook" {
		t.Fatalf("im platform = %q, want kook", im.last.Platform)
	}
}

func TestPusher_NoIMSink_DegradesToActive(t *testing.T) {
	t.Parallel()
	// With no IM sink wired (backthink IM seam absent) the push degrades to the
	// active web client so the owner is still reached rather than dropped.
	active := &mockActive{n: 1}
	p := newPusher(active, nil, &mockGate{allow: true}, discardLog())

	res := p.Push(context.Background(), PushRequest{Message: adapter.UnifiedMessage{}})

	if !res.Pushed {
		t.Fatalf("Pushed = false, want true")
	}
	if res.Route != RouteActiveClient {
		t.Fatalf("Route = %q, want %q", res.Route, RouteActiveClient)
	}
	if active.calls != 1 {
		t.Fatalf("active calls = %d, want 1", active.calls)
	}
}

func TestPusher_NoTarget_Skipped(t *testing.T) {
	t.Parallel()
	p := newPusher(nil, nil, &mockGate{allow: true}, discardLog())

	res := p.Push(context.Background(), PushRequest{Message: adapter.UnifiedMessage{}})

	if res.Pushed {
		t.Fatalf("Pushed = true, want false")
	}
	if res.Route != RouteNone {
		t.Fatalf("Route = %q, want %q", res.Route, RouteNone)
	}
}

func TestPusher_GateDenied(t *testing.T) {
	t.Parallel()
	active := &mockActive{n: 1}
	im := &mockIMAdapter{}
	p := newPusher(active, im, &mockGate{allow: false}, discardLog())

	res := p.Push(context.Background(), PushRequest{Message: adapter.UnifiedMessage{}})

	if res.Pushed {
		t.Fatalf("Pushed = true, want false")
	}
	if res.Route != RouteRateLimited {
		t.Fatalf("Route = %q, want %q", res.Route, RouteRateLimited)
	}
	if active.calls != 0 || im.count() != 0 {
		t.Fatalf("targets called despite denial: active=%d im=%d", active.calls, im.count())
	}
}

func TestPusher_CancelledContext_Denied(t *testing.T) {
	t.Parallel()
	active := &mockActive{n: 1}
	p := newPusher(active, nil, &mockGate{allow: true}, discardLog())
	ctx, cancel := context.WithCancel(context.Background())
	cancel()

	res := p.Push(ctx, PushRequest{Message: adapter.UnifiedMessage{}})

	if res.Pushed {
		t.Fatalf("Pushed = true, want false")
	}
	if res.Route != RouteNone {
		t.Fatalf("Route = %q, want %q", res.Route, RouteNone)
	}
	if active.calls != 0 {
		t.Fatalf("active calls = %d, want 0", active.calls)
	}
}

// TestPusher_RateLimit exercises the production rateGate over session.RateLimiter:
// with a limit of 1 push per window, only the first of three attempts passes.
func TestPusher_RateLimit(t *testing.T) {
	t.Parallel()
	active := &mockActive{n: 1}
	p := newPusher(active, nil, newRateGate(1, time.Minute, 0, 0, discardLog()), discardLog())

	first := p.Push(context.Background(), PushRequest{Message: adapter.UnifiedMessage{}})
	second := p.Push(context.Background(), PushRequest{Message: adapter.UnifiedMessage{}})
	third := p.Push(context.Background(), PushRequest{Message: adapter.UnifiedMessage{}})

	if !first.Pushed || first.Route != RouteActiveClient {
		t.Fatalf("first push = %+v, want active_client pushed", first)
	}
	if second.Pushed || second.Route != RouteRateLimited {
		t.Fatalf("second push = %+v, want rate_limited not pushed", second)
	}
	if third.Pushed || third.Route != RouteRateLimited {
		t.Fatalf("third push = %+v, want rate_limited not pushed", third)
	}
	if active.calls != 1 {
		t.Fatalf("active calls = %d, want 1 (rate limit caps the sink)", active.calls)
	}
}

// TestRateGate_CooldownAfterSuccess verifies the post-push cooldown: after a
// successful delivery a further push is refused until the cooldown elapses,
// regardless of the configured window counter.
func TestRateGate_CooldownAfterSuccess(t *testing.T) {
	t.Parallel()
	t0 := time.Now()
	g := &rateGate{
		log:        discardLog(),
		limiter:    session.NewRateLimiter(10, time.Hour),
		cooldown:   30 * time.Minute,
		kindWindow: 0, // disabled to isolate the cooldown
		now:        func() time.Time { return t0 },
		lastKind:   make(map[PushKind]time.Time),
	}
	if !g.Allow(context.Background(), KindCare) {
		t.Fatal("first push should be allowed")
	}
	g.RecordPush(KindCare)
	if g.Allow(context.Background(), KindReminder) {
		t.Fatal("push within cooldown should be denied")
	}
	g.now = func() time.Time { return t0.Add(31 * time.Minute) }
	if !g.Allow(context.Background(), KindReminder) {
		t.Fatal("push after the cooldown has elapsed should be allowed")
	}
}

// TestRateGate_KindWindowLimitsSameFlavor verifies the per-flavor (问候/提醒/分享/
// 关心) limit: the same flavor cannot repeat within the kind window, while a
// different flavor and a later same-flavor push (after the window) still pass.
func TestRateGate_KindWindowLimitsSameFlavor(t *testing.T) {
	t.Parallel()
	t0 := time.Now()
	g := &rateGate{
		log:        discardLog(),
		limiter:    session.NewRateLimiter(10, time.Hour),
		cooldown:   0, // disabled to isolate the kind window
		kindWindow: 2 * time.Hour,
		now:        func() time.Time { return t0 },
		lastKind:   make(map[PushKind]time.Time),
	}
	if !g.Allow(context.Background(), KindReminder) {
		t.Fatal("first reminder should be allowed")
	}
	g.RecordPush(KindReminder)
	if g.Allow(context.Background(), KindReminder) {
		t.Fatal("same flavor within the kind window should be denied")
	}
	if !g.Allow(context.Background(), KindShare) {
		t.Fatal("a different flavor should be allowed")
	}
	g.now = func() time.Time { return t0.Add(3 * time.Hour) }
	if !g.Allow(context.Background(), KindReminder) {
		t.Fatal("same flavor after the kind window should be allowed")
	}
}