《互联网产品的服务端架构·内容、社交与实时互动》6.1 点赞、评论与收藏

// file: internal/counter/count.go
// tier: L1
// verify: go test ./internal/counter/

package counter

import (
	"fmt"
	"math"
)

// Counter 是互动计数的种类。点赞、评论、收藏的写入路径不同，
// 但都需要在同一套计数模型上做增减，不能用 bool 或裸字符串区分。
type Counter string

const (
	Like     Counter = "like"
	Comment  Counter = "comment"
	Favorite Counter = "favorite"
)

// Key 定位一个目标的某一类计数。TargetID 是内容 ID，不能为空；
// Counter 必须是 Like、Comment、Favorite 之一。
type Key struct {
	Counter  Counter
	TargetID string
}

func (k Key) validate() error {
	if k.TargetID == "" {
		return fmt.Errorf("counter: empty target id")
	}
	switch k.Counter {
	case Like, Comment, Favorite:
		return nil
	default:
		return fmt.Errorf("counter: unknown counter %q", k.Counter)
	}
}

// Delta 是一条待应用的计数增量。Value 可以为负（取消点赞、删评论），
// 但是否允许扣减由具体业务决定，Apply 只保证结果不为负。
type Delta struct {
	Key   Key
	Value int64
}

// Apply 把一批增量累加到 base 上，返回新值。它不修改调用方传入的切片，
// 也不依赖 Delta 的顺序：同一 key 的多条增量会先求和再一次性应用。
// 未知 counter、空 target、int64 溢出和负数结果都会返回 error。
func Apply(base int64, deltas []Delta) (int64, error) {
	var sum int64
	for i, d := range deltas {
		if err := d.Key.validate(); err != nil {
			return 0, fmt.Errorf("counter: delta %d: %w", i, err)
		}
		if d.Value > 0 && sum > math.MaxInt64-d.Value {
			return 0, fmt.Errorf("counter: delta %d overflows int64: %d + %d", i, sum, d.Value)
		}
		if d.Value < 0 && sum < math.MinInt64-d.Value {
			return 0, fmt.Errorf("counter: delta %d underflows int64: %d + %d", i, sum, d.Value)
		}
		sum += d.Value
	}
	if sum > 0 && base > math.MaxInt64-sum {
		return 0, fmt.Errorf("counter: base %d plus sum %d overflows int64", base, sum)
	}
	if sum < 0 && base < math.MinInt64-sum {
		return 0, fmt.Errorf("counter: base %d plus sum %d underflows int64", base, sum)
	}
	result := base + sum
	if result < 0 {
		return 0, fmt.Errorf("counter: result would be negative: %d + %d = %d", base, sum, result)
	}
	return result, nil
}

// file: internal/counter/count_test.go
// tier: L1
// verify: go test ./internal/counter/

package counter

import (
	"math"
	"reflect"
	"testing"
)

func TestApplyAccumulatesSameKey(t *testing.T) {
	deltas := []Delta{
		{Key: Key{Counter: Like, TargetID: "post-1"}, Value: 2},
		{Key: Key{Counter: Like, TargetID: "post-1"}, Value: 3},
		{Key: Key{Counter: Like, TargetID: "post-1"}, Value: -1},
	}
	before := append([]Delta(nil), deltas...)

	got, err := Apply(10, deltas)
	if err != nil {
		t.Fatalf("Apply = %v, want nil", err)
	}
	if got != 14 {
		t.Fatalf("Apply = %d, want 14", got)
	}
	if !reflect.DeepEqual(deltas, before) {
		t.Fatalf("Apply mutated input: got %+v, want %+v", deltas, before)
	}
}

func TestApplyAllowsZeroAndNegativeBaseErrors(t *testing.T) {
	got, err := Apply(0, nil)
	if err != nil || got != 0 {
		t.Fatalf("Apply(0, nil) = %d, %v; want 0, nil", got, err)
	}

	got, err = Apply(1, []Delta{{Key: Key{Counter: Favorite, TargetID: "post-1"}, Value: 0}})
	if err != nil || got != 1 {
		t.Fatalf("Apply zero delta = %d, %v; want 1, nil", got, err)
	}

	if _, err := Apply(1, []Delta{{Key: Key{Counter: Like, TargetID: "post-1"}, Value: -2}}); err == nil {
		t.Fatal("Apply to negative = nil, want error")
	}
}

func TestApplyRejectsBadKeys(t *testing.T) {
	cases := []struct {
		name string
		key  Key
	}{
		{"empty-target", Key{Counter: Like, TargetID: ""}},
		{"unknown-counter", Key{Counter: Counter("share"), TargetID: "post-1"}},
		{"empty-counter", Key{TargetID: "post-1"}},
	}
	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			_, err := Apply(0, []Delta{{Key: c.key, Value: 1}})
			if err == nil {
				t.Fatalf("Apply(%+v) = nil, want error", c.key)
			}
		})
	}
}

func TestApplyDetectsOverflow(t *testing.T) {
	big := []Delta{
		{Key: Key{Counter: Like, TargetID: "post-1"}, Value: math.MaxInt64},
		{Key: Key{Counter: Like, TargetID: "post-1"}, Value: 1},
	}
	if _, err := Apply(0, big); err == nil {
		t.Fatal("Apply overflow = nil, want error")
	}

	if _, err := Apply(math.MaxInt64, []Delta{{Key: Key{Counter: Like, TargetID: "post-1"}, Value: 1}}); err == nil {
		t.Fatal("Apply base overflow = nil, want error")
	}
}

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

=== RUN   TestApplyAccumulatesSameKey
--- PASS: TestApplyAccumulatesSameKey (0.00s)
=== RUN   TestApplyAllowsZeroAndNegativeBaseErrors
--- PASS: TestApplyAllowsZeroAndNegativeBaseErrors (0.00s)
=== RUN   TestApplyRejectsBadKeys
=== RUN   TestApplyRejectsBadKeys/empty-target
=== RUN   TestApplyRejectsBadKeys/unknown-counter
=== RUN   TestApplyRejectsBadKeys/empty-counter
--- PASS: TestApplyRejectsBadKeys (0.00s)
    --- PASS: TestApplyRejectsBadKeys/empty-target (0.00s)
    --- PASS: TestApplyRejectsBadKeys/unknown-counter (0.00s)
    --- PASS: TestApplyRejectsBadKeys/empty-counter (0.00s)
=== RUN   TestApplyDetectsOverflow
--- PASS: TestApplyDetectsOverflow (0.00s)
PASS
ok  	webapp/internal/counter	0.349s