《互联网产品的服务端架构·交易、增长与平台化》6.3 防刷、风控与兜底

// file: internal/activity/risk.go
// tier: L1
// verify: go test ./internal/activity/

package activity

import (
	"errors"
	"fmt"
)

var (
	// ErrInvalidRule 表示风控规则出现负数。
	ErrInvalidRule = errors.New("activity: invalid risk rule")
	// ErrRiskClockBackwards 表示历史事件的时间晚于当前事件。
	ErrRiskClockBackwards = errors.New("activity: risk clock backwards")
)

// Event 是一次待判定的行为事件。三个维度都可以为空，空维度不参与风控；
// At 是 Unix 秒。
type Event struct {
	UserID   string
	DeviceID string
	IP       string
	At       int64
}

// Rule 是滑动窗口规则。WindowSeconds 是窗口长度；三个 Max 字段为 0 表示
// 该维度不限制。Max 是窗口内允许出现的总次数，包含本次请求。
type Rule struct {
	WindowSeconds int64
	MaxPerUser    int
	MaxPerDevice  int
	MaxPerIP      int
}

// Check 判断事件 e 是否仍在规则允许范围内。窗口是闭区间
// [e.At-WindowSeconds, e.At]，历史事件里晚于 e.At 的记录说明时间倒退，
// 直接报错。任一维度达到上限就返回 false；返回错误时调用方应走降级路径，
// 而不是把用户当成正常或异常。
func Check(history []Event, e Event, r Rule) (bool, error) {
	if r.WindowSeconds < 0 || r.MaxPerUser < 0 || r.MaxPerDevice < 0 || r.MaxPerIP < 0 {
		return false, fmt.Errorf("%w: %+v", ErrInvalidRule, r)
	}
	start := e.At - r.WindowSeconds
	var user, device, ip int
	for _, h := range history {
		if h.At > e.At {
			return false, fmt.Errorf("%w: history at %d > event at %d",
				ErrRiskClockBackwards, h.At, e.At)
		}
		if h.At < start {
			continue
		}
		if e.UserID != "" && h.UserID == e.UserID {
			user++
		}
		if e.DeviceID != "" && h.DeviceID == e.DeviceID {
			device++
		}
		if e.IP != "" && h.IP == e.IP {
			ip++
		}
	}
	switch {
	case r.MaxPerUser > 0 && user >= r.MaxPerUser:
		return false, nil
	case r.MaxPerDevice > 0 && device >= r.MaxPerDevice:
		return false, nil
	case r.MaxPerIP > 0 && ip >= r.MaxPerIP:
		return false, nil
	}
	return true, nil
}

// file: internal/activity/risk_test.go
// tier: L1
// verify: go test ./internal/activity/

package activity

import (
	"errors"
	"testing"
)

func TestCheckCountsInclusiveWindow(t *testing.T) {
	r := Rule{WindowSeconds: 60, MaxPerUser: 2}
	e := Event{UserID: "u1", At: 100}
	history := []Event{
		{UserID: "u1", At: 39},
		{UserID: "u1", At: 40},
	}
	ok, err := Check(history, e, r)
	if err != nil || !ok {
		t.Fatalf("Check at start boundary = %v, %v; want true, nil", ok, err)
	}
	history = append(history, Event{UserID: "u1", At: 100})
	ok, err = Check(history, e, r)
	if err != nil || ok {
		t.Fatalf("Check with two in-window events = %v, %v; want false, nil", ok, err)
	}
}

func TestCheckRejectsEachDimension(t *testing.T) {
	e := Event{UserID: "u1", DeviceID: "d1", IP: "10.0.0.1", At: 100}
	cases := []struct {
		name    string
		rule    Rule
		history []Event
	}{
		{"user", Rule{WindowSeconds: 60, MaxPerUser: 1}, []Event{{UserID: "u1", At: 90}}},
		{"device", Rule{WindowSeconds: 60, MaxPerDevice: 1}, []Event{{DeviceID: "d1", At: 90}}},
		{"ip", Rule{WindowSeconds: 60, MaxPerIP: 1}, []Event{{IP: "10.0.0.1", At: 90}}},
	}
	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			ok, err := Check(c.history, e, c.rule)
			if err != nil || ok {
				t.Fatalf("Check = %v, %v; want false, nil", ok, err)
			}
		})
	}
}

func TestCheckZeroMeansUnlimited(t *testing.T) {
	e := Event{UserID: "u1", DeviceID: "d1", IP: "10.0.0.1", At: 100}
	history := []Event{
		{UserID: "u1", DeviceID: "d1", IP: "10.0.0.1", At: 90},
		{UserID: "u1", DeviceID: "d1", IP: "10.0.0.1", At: 91},
	}
	ok, err := Check(history, e, Rule{WindowSeconds: 60})
	if err != nil || !ok {
		t.Fatalf("Check unlimited = %v, %v; want true, nil", ok, err)
	}
}

func TestCheckSkipsEmptyDimension(t *testing.T) {
	e := Event{UserID: "", DeviceID: "d1", IP: "", At: 100}
	history := []Event{
		{UserID: "", At: 99},
		{UserID: "", At: 98},
	}
	ok, err := Check(history, e, Rule{WindowSeconds: 60, MaxPerUser: 1, MaxPerIP: 1})
	if err != nil || !ok {
		t.Fatalf("Check empty dimensions = %v, %v; want true, nil", ok, err)
	}
}

func TestCheckRejectsBackwardsHistory(t *testing.T) {
	e := Event{UserID: "u1", At: 100}
	history := []Event{{UserID: "u1", At: 101}}
	if _, err := Check(history, e, Rule{WindowSeconds: 60, MaxPerUser: 2}); !errors.Is(err, ErrRiskClockBackwards) {
		t.Fatalf("backwards history = %v, want ErrRiskClockBackwards", err)
	}
}

func TestCheckRejectsInvalidRule(t *testing.T) {
	e := Event{UserID: "u1", At: 100}
	cases := []Rule{
		{WindowSeconds: -1},
		{WindowSeconds: 60, MaxPerUser: -1},
		{WindowSeconds: 60, MaxPerDevice: -1},
		{WindowSeconds: 60, MaxPerIP: -1},
	}
	for _, r := range cases {
		if _, err := Check(nil, e, r); !errors.Is(err, ErrInvalidRule) {
			t.Fatalf("Check(%+v) = %v, want ErrInvalidRule", r, err)
		}
	}
}

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

=== RUN   TestCheckCountsInclusiveWindow
--- PASS: TestCheckCountsInclusiveWindow (0.00s)
=== RUN   TestCheckRejectsEachDimension
=== RUN   TestCheckRejectsEachDimension/user
=== RUN   TestCheckRejectsEachDimension/device
=== RUN   TestCheckRejectsEachDimension/ip
--- PASS: TestCheckRejectsEachDimension (0.00s)
    --- PASS: TestCheckRejectsEachDimension/user (0.00s)
    --- PASS: TestCheckRejectsEachDimension/device (0.00s)
    --- PASS: TestCheckRejectsEachDimension/ip (0.00s)
=== RUN   TestCheckZeroMeansUnlimited
--- PASS: TestCheckZeroMeansUnlimited (0.00s)
=== RUN   TestCheckSkipsEmptyDimension
--- PASS: TestCheckSkipsEmptyDimension (0.00s)
=== RUN   TestCheckRejectsBackwardsHistory
--- PASS: TestCheckRejectsBackwardsHistory (0.00s)
=== RUN   TestCheckRejectsInvalidRule
--- PASS: TestCheckRejectsInvalidRule (0.00s)
PASS
ok  	webapp/internal/activity	0.229s