《互联网产品的服务端架构·内容、社交与实时互动》7.3 互动通知的触发边界

// file: internal/comment/notify.go
// tier: L1
// verify: go test ./internal/comment/

package comment

import "fmt"

// Action 是互动类型。不同 Action 分开聚合，点赞不会吃掉评论通知。
type Action string

const (
	ActionLike    Action = "like"
	ActionComment Action = "comment"
	ActionReply   Action = "reply"
	ActionMention Action = "mention"
)

// Event 是一条待判定的互动事件。OwnerID 是被互动内容的作者，
// TargetID 是被互动的对象（动态、评论或会话）。
type Event struct {
	ID       string
	ActorID  string
	OwnerID  string
	TargetID string
	Action   Action
	At       int64
}

// ShouldNotify 判断一条互动是否应该产生通知，并返回可读原因。
// 自己被自己操作、作者被屏蔽、时间戳晚于 now、以及同一
// (Owner, Target, Action) 在 aggregateWindow 秒内重复触发都不通知。
// 通知成立时会更新 last，调用方传入 nil 则跳过聚合记录。
func ShouldNotify(e Event, muted map[string]bool, aggregateWindow, now int64, last map[string]int64) (bool, string) {
	if e.ActorID == "" || e.OwnerID == "" || e.TargetID == "" {
		return false, "invalid event: actor, owner and target are required"
	}
	if !validAction(e.Action) {
		return false, fmt.Sprintf("invalid action %q", e.Action)
	}
	if e.ActorID == e.OwnerID {
		return false, "self action: actor owns the target"
	}
	if muted[e.ActorID] {
		return false, "actor is muted by owner"
	}
	if e.At > now {
		return false, "event timestamp is in the future"
	}
	if aggregateWindow > 0 && last != nil {
		key := aggregateKey(e)
		if prev, ok := last[key]; ok && now-prev < aggregateWindow {
			return false, fmt.Sprintf("aggregated: %s within %d seconds", e.Action, aggregateWindow)
		}
		last[key] = now
	}
	return true, fmt.Sprintf("notify: %s from %s", e.Action, e.ActorID)
}

func aggregateKey(e Event) string {
	return e.OwnerID + "\x00" + e.TargetID + "\x00" + string(e.Action)
}

func validAction(a Action) bool {
	switch a {
	case ActionLike, ActionComment, ActionReply, ActionMention:
		return true
	default:
		return false
	}
}

// file: internal/comment/notify_test.go
// tier: L1
// verify: go test ./internal/comment/

package comment

import (
	"strings"
	"testing"
)

func TestShouldNotifySelfAndMuted(t *testing.T) {
	now := int64(1000)
	if ok, reason := ShouldNotify(Event{ActorID: "u1", OwnerID: "u1", TargetID: "p1", Action: ActionLike, At: now}, nil, 60, now, nil); ok || !strings.Contains(reason, "self") {
		t.Fatalf("self action = %v %q", ok, reason)
	}
	muted := map[string]bool{"spammer": true}
	if ok, reason := ShouldNotify(Event{ActorID: "spammer", OwnerID: "u1", TargetID: "p1", Action: ActionComment, At: now}, muted, 60, now, nil); ok || !strings.Contains(reason, "muted") {
		t.Fatalf("muted actor = %v %q", ok, reason)
	}
}

func TestShouldNotifyAggregatesWindow(t *testing.T) {
	now := int64(1000)
	last := make(map[string]int64)
	first := Event{ActorID: "u2", OwnerID: "u1", TargetID: "p1", Action: ActionLike, At: now}
	if ok, _ := ShouldNotify(first, nil, 60, now, last); !ok {
		t.Fatal("first like should notify")
	}
	repeat := first
	repeat.At = now + 10
	if ok, reason := ShouldNotify(repeat, nil, 60, now+10, last); ok || !strings.Contains(reason, "aggregated") {
		t.Fatalf("repeat like = %v %q", ok, reason)
	}
	repeat.At = now + 61
	if ok, _ := ShouldNotify(repeat, nil, 60, now+61, last); !ok {
		t.Fatal("like after window should notify again")
	}
}

func TestShouldNotifySeparatesDimensions(t *testing.T) {
	now := int64(1000)
	last := make(map[string]int64)
	base := Event{ActorID: "u2", OwnerID: "u1", TargetID: "p1", Action: ActionLike, At: now}
	if ok, _ := ShouldNotify(base, nil, 60, now, last); !ok {
		t.Fatal("first event should notify")
	}
	otherTarget := base
	otherTarget.TargetID = "p2"
	if ok, _ := ShouldNotify(otherTarget, nil, 60, now+1, last); !ok {
		t.Fatal("different target must notify")
	}
	otherAction := base
	otherAction.Action = ActionReply
	if ok, _ := ShouldNotify(otherAction, nil, 60, now+2, last); !ok {
		t.Fatal("different action must notify")
	}
}

func TestShouldNotifyRejectsBadEvents(t *testing.T) {
	now := int64(1000)
	cases := []struct {
		name string
		e    Event
		want string
	}{
		{"missing actor", Event{OwnerID: "u1", TargetID: "p1", Action: ActionLike, At: now}, "invalid event"},
		{"unknown action", Event{ActorID: "u2", OwnerID: "u1", TargetID: "p1", Action: "share", At: now}, "invalid action"},
		{"future", Event{ActorID: "u2", OwnerID: "u1", TargetID: "p1", Action: ActionLike, At: now + 1}, "future"},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			if ok, reason := ShouldNotify(tc.e, nil, 60, now, nil); ok || !strings.Contains(reason, tc.want) {
				t.Fatalf("got %v %q, want reason containing %q", ok, reason, tc.want)
			}
		})
	}
}

cd .local/checks/webapp-lab && go test ./internal/comment/ -run 'TestShouldNotify' -count=1 -v

=== RUN   TestShouldNotifySelfAndMuted
--- PASS: TestShouldNotifySelfAndMuted (0.00s)
=== RUN   TestShouldNotifyAggregatesWindow
--- PASS: TestShouldNotifyAggregatesWindow (0.00s)
=== RUN   TestShouldNotifySeparatesDimensions
--- PASS: TestShouldNotifySeparatesDimensions (0.00s)
=== RUN   TestShouldNotifyRejectsBadEvents
=== RUN   TestShouldNotifyRejectsBadEvents/missing_actor
=== RUN   TestShouldNotifyRejectsBadEvents/unknown_action
=== RUN   TestShouldNotifyRejectsBadEvents/future
--- PASS: TestShouldNotifyRejectsBadEvents (0.00s)
    --- PASS: TestShouldNotifyRejectsBadEvents/missing_actor (0.00s)
    --- PASS: TestShouldNotifyRejectsBadEvents/unknown_action (0.00s)
    --- PASS: TestShouldNotifyRejectsBadEvents/future (0.00s)
PASS
ok  	webapp/internal/comment	0.231s