《互联网产品的服务端架构·内容、社交与实时互动》4.1 时间、热度与多样性

// file: internal/rank/score.go
// tier: L1
// verify: go test ./internal/rank/

package rank

import (
	"fmt"
	"sort"
)

// Weights 是四类信号在最终得分中的权重。
type Weights struct {
	Recency  float64
	Likes    float64
	Comments float64
	Affinity float64
}

// Item 是排序的最小输入，不依赖存储层。
type Item struct {
	ID       string
	AuthorID string
	AgeHours float64
	Likes    int
	Comments int
	Affinity float64
}

// Score 计算单条内容的得分。时间使用 1/(1+AgeHours) 衰减。
func Score(i Item, w Weights) (float64, error) {
	if w.Recency < 0 || w.Likes < 0 || w.Comments < 0 || w.Affinity < 0 {
		return 0, fmt.Errorf("weights must be >= 0: %+v", w)
	}
	if w.Recency+w.Likes+w.Comments+w.Affinity <= 0 {
		return 0, fmt.Errorf("weights must sum to a positive value")
	}
	if i.AgeHours < 0 {
		return 0, fmt.Errorf("item %q age hours must be >= 0, got %f", i.ID, i.AgeHours)
	}
	if i.Likes < 0 {
		return 0, fmt.Errorf("item %q likes must be >= 0, got %d", i.ID, i.Likes)
	}
	if i.Comments < 0 {
		return 0, fmt.Errorf("item %q comments must be >= 0, got %d", i.ID, i.Comments)
	}

	recency := 1 / (1 + i.AgeHours)
	return w.Recency*recency +
		w.Likes*float64(i.Likes) +
		w.Comments*float64(i.Comments) +
		w.Affinity*i.Affinity, nil
}

// Sort 返回按得分从高到低排列的副本，不修改入参。
func Sort(items []Item, w Weights) ([]Item, error) {
	out := make([]Item, len(items))
	copy(out, items)

	scores := make([]float64, len(out))
	for idx, it := range out {
		s, err := Score(it, w)
		if err != nil {
			return nil, err
		}
		scores[idx] = s
	}

	// 先算分再排序，避免比较函数里重复计算或吞掉错误。
	order := make([]int, len(out))
	for i := range order {
		order[i] = i
	}
	sort.SliceStable(order, func(a, b int) bool {
		return scores[order[a]] > scores[order[b]]
	})

	sorted := make([]Item, len(out))
	for i, idx := range order {
		sorted[i] = out[idx]
	}
	return sorted, nil
}

// file: internal/rank/score_test.go
// tier: L1
// verify: go test ./internal/rank/

package rank

import (
	"math"
	"testing"
)

func almostEqual(a, b float64) bool { return math.Abs(a-b) < 1e-9 }

func TestScoreCombinesSignals(t *testing.T) {
	item := Item{
		ID:       "p1",
		AuthorID: "u1",
		AgeHours: 1,
		Likes:    10,
		Comments: 2,
		Affinity: 0.8,
	}
	w := Weights{Recency: 0.4, Likes: 0.3, Comments: 0.2, Affinity: 0.1}

	got, err := Score(item, w)
	if err != nil {
		t.Fatalf("Score returned error: %v", err)
	}
	// 0.4*0.5 + 0.3*10 + 0.2*2 + 0.1*0.8 = 3.68
	if !almostEqual(got, 3.68) {
		t.Fatalf("Score = %f, want 3.68", got)
	}
}

func TestScoreDecaysWithAge(t *testing.T) {
	w := Weights{Recency: 1}

	fresh, err := Score(Item{ID: "fresh", AgeHours: 0}, w)
	if err != nil {
		t.Fatalf("Score returned error: %v", err)
	}
	old, err := Score(Item{ID: "old", AgeHours: 3}, w)
	if err != nil {
		t.Fatalf("Score returned error: %v", err)
	}
	if !almostEqual(fresh, 1) {
		t.Fatalf("fresh score = %f, want 1", fresh)
	}
	if !almostEqual(old, 0.25) {
		t.Fatalf("old score = %f, want 0.25", old)
	}
}

func TestScoreRejectsNegativeWeights(t *testing.T) {
	_, err := Score(Item{ID: "p1"}, Weights{Recency: 1, Likes: -0.1})
	if err == nil {
		t.Fatal("expected an error for a negative weight")
	}
}

func TestScoreRejectsZeroWeights(t *testing.T) {
	_, err := Score(Item{ID: "p1"}, Weights{})
	if err == nil {
		t.Fatal("expected an error when every weight is zero")
	}
}

func TestScoreRejectsNegativeCounts(t *testing.T) {
	w := Weights{Likes: 1}

	if _, err := Score(Item{ID: "p1", Likes: -1}, w); err == nil {
		t.Fatal("expected an error for negative likes")
	}
	if _, err := Score(Item{ID: "p1", Comments: -1}, w); err == nil {
		t.Fatal("expected an error for negative comments")
	}
}

func TestScoreRejectsNegativeAge(t *testing.T) {
	if _, err := Score(Item{ID: "p1", AgeHours: -0.5}, Weights{Recency: 1}); err == nil {
		t.Fatal("expected an error for a negative age")
	}
}

func TestSortDescendingAndStable(t *testing.T) {
	items := []Item{
		{ID: "low", AgeHours: 10, Likes: 1},
		{ID: "tie-a", AgeHours: 0, Likes: 5},
		{ID: "high", AgeHours: 0, Likes: 9},
		{ID: "tie-b", AgeHours: 0, Likes: 5},
	}
	original := make([]Item, len(items))
	copy(original, items)

	got, err := Sort(items, Weights{Likes: 1})
	if err != nil {
		t.Fatalf("Sort returned error: %v", err)
	}

	want := []string{"high", "tie-a", "tie-b", "low"}
	for i, id := range want {
		if got[i].ID != id {
			t.Fatalf("position %d = %q, want %q", i, got[i].ID, id)
		}
	}

	for i := range items {
		if items[i] != original[i] {
			t.Fatalf("Sort modified the input at position %d", i)
		}
	}
}

func TestSortPropagatesScoreError(t *testing.T) {
	items := []Item{
		{ID: "ok", Likes: 1},
		{ID: "bad", Likes: -1},
	}
	if _, err := Sort(items, Weights{Likes: 1}); err == nil {
		t.Fatal("expected the invalid item to fail the sort")
	}
}

func TestSortEmpty(t *testing.T) {
	got, err := Sort(nil, Weights{Recency: 1})
	if err != nil {
		t.Fatalf("Sort returned error: %v", err)
	}
	if len(got) != 0 {
		t.Fatalf("len = %d, want 0", len(got))
	}
}

cd .local/checks/webapp-lab && go test ./internal/rank/ -count=1 -run 'TestScore|TestSort' -v

=== RUN   TestScoreCombinesSignals
--- PASS: TestScoreCombinesSignals (0.00s)
=== RUN   TestScoreDecaysWithAge
--- PASS: TestScoreDecaysWithAge (0.00s)
=== RUN   TestScoreRejectsNegativeWeights
--- PASS: TestScoreRejectsNegativeWeights (0.00s)
=== RUN   TestScoreRejectsZeroWeights
--- PASS: TestScoreRejectsZeroWeights (0.00s)
=== RUN   TestScoreRejectsNegativeCounts
--- PASS: TestScoreRejectsNegativeCounts (0.00s)
=== RUN   TestScoreRejectsNegativeAge
--- PASS: TestScoreRejectsNegativeAge (0.00s)
=== RUN   TestSortDescendingAndStable
--- PASS: TestSortDescendingAndStable (0.00s)
=== RUN   TestSortPropagatesScoreError
--- PASS: TestSortPropagatesScoreError (0.00s)
=== RUN   TestSortEmpty
--- PASS: TestSortEmpty (0.00s)
PASS
ok  	webapp/internal/rank	0.293s