《互联网产品的服务端架构·规模化与架构演进》11.2 限流、降级与预案

// file: internal/promo/plan.go
// tier: L1
// verify: go test ./internal/promo/

package promo

import "fmt"

// Measure 是预案中的一个限流/降级动作。
// Name 是接口名，Limit 是每秒允许的请求数，Degrade 是超限后的降级动作。
type Measure struct {
	Name    string
	Limit   int
	Degrade string
}

// Validate 检查预案是否可执行。
// 每个列出的接口都必须有降级动作；接口名不能为空或重复；
// Limit 必须为正数，否则等于没有限流。
func Validate(ms []Measure) error {
	seen := make(map[string]struct{}, len(ms))
	for i, m := range ms {
		if m.Name == "" {
			return fmt.Errorf("promo: measure at index %d has empty name", i)
		}
		if m.Limit <= 0 {
			return fmt.Errorf("promo: measure %q has non-positive limit %d", m.Name, m.Limit)
		}
		if m.Degrade == "" {
			return fmt.Errorf("promo: measure %q has no degrade action", m.Name)
		}
		if _, ok := seen[m.Name]; ok {
			return fmt.Errorf("promo: duplicate measure %q", m.Name)
		}
		seen[m.Name] = struct{}{}
	}
	return nil
}

// Coverage 返回必需接口中有降级动作的比例。
// required 是必须覆盖的接口清单；同一接口重复出现只算一次。
// 空清单返回 0：没有声明必需接口时，不应该报告“100% 覆盖”。
func Coverage(ms []Measure, required []string) float64 {
	if len(required) == 0 {
		return 0
	}
	have := make(map[string]struct{}, len(ms))
	for _, m := range ms {
		if m.Degrade != "" {
			have[m.Name] = struct{}{}
		}
	}
	seen := make(map[string]struct{}, len(required))
	covered := 0
	for _, name := range required {
		if _, ok := seen[name]; ok {
			continue
		}
		seen[name] = struct{}{}
		if _, ok := have[name]; ok {
			covered++
		}
	}
	return float64(covered) / float64(len(seen))
}

// file: internal/promo/plan_test.go
// tier: L1
// verify: go test ./internal/promo/

package promo

import (
	"math"
	"strings"
	"testing"
)

func TestValidateAcceptsCompletePlan(t *testing.T) {
	ms := []Measure{
		{Name: "order.create", Limit: 5000, Degrade: "返回排队中，异步落单"},
		{Name: "product.detail", Limit: 20000, Degrade: "读缓存并关闭实时库存"},
	}
	if err := Validate(ms); err != nil {
		t.Fatalf("Validate returned error: %v", err)
	}
}

func TestValidateRejectsMissingDegrade(t *testing.T) {
	ms := []Measure{{Name: "order.create", Limit: 5000}}
	err := Validate(ms)
	if err == nil {
		t.Fatal("want error when a core interface has no degrade action")
	}
	if !strings.Contains(err.Error(), "degrade") {
		t.Fatalf("error %q should mention degrade", err)
	}
}

func TestValidateRejectsDuplicateName(t *testing.T) {
	ms := []Measure{
		{Name: "order.create", Limit: 5000, Degrade: "排队"},
		{Name: "order.create", Limit: 3000, Degrade: "直接拒绝"},
	}
	if err := Validate(ms); err == nil {
		t.Fatal("want error for duplicate measure name")
	}
}

func TestValidateRejectsBadNameAndLimit(t *testing.T) {
	cases := []Measure{
		{Name: "", Limit: 100, Degrade: "拒绝"},
		{Name: "pay.callback", Limit: 0, Degrade: "拒绝"},
		{Name: "pay.callback", Limit: -1, Degrade: "拒绝"},
	}
	for _, m := range cases {
		if err := Validate([]Measure{m}); err == nil {
			t.Fatalf("Validate(%+v) = nil, want error", m)
		}
	}
}

func TestCoverageCountsRequiredInterfaces(t *testing.T) {
	ms := []Measure{
		{Name: "order.create", Limit: 5000, Degrade: "排队"},
		{Name: "product.detail", Limit: 20000, Degrade: "读缓存"},
	}
	required := []string{"order.create", "product.detail", "pay.callback"}
	got := Coverage(ms, required)
	if math.Abs(got-2.0/3.0) > 1e-9 {
		t.Fatalf("Coverage = %v, want 2/3", got)
	}
}

func TestCoverageIgnoresDuplicates(t *testing.T) {
	ms := []Measure{{Name: "order.create", Limit: 5000, Degrade: "排队"}}
	required := []string{"order.create", "order.create"}
	if got := Coverage(ms, required); math.Abs(got-1) > 1e-9 {
		t.Fatalf("Coverage = %v, want 1", got)
	}
}

func TestCoverageDoesNotCountEmptyDegrade(t *testing.T) {
	ms := []Measure{{Name: "order.create", Limit: 5000}}
	if got := Coverage(ms, []string{"order.create"}); got != 0 {
		t.Fatalf("Coverage = %v, want 0 for empty degrade", got)
	}
}

func TestCoverageEmptyRequiredIsZero(t *testing.T) {
	if got := Coverage(nil, nil); got != 0 {
		t.Fatalf("Coverage with no required interfaces = %v, want 0", got)
	}
}

cd .local/checks/webapp-lab && go test ./internal/promo/ -run 'TestValidate|TestCoverage' -count=1 -v

=== RUN   TestValidateAcceptsCompletePlan
--- PASS: TestValidateAcceptsCompletePlan (0.00s)
=== RUN   TestValidateRejectsMissingDegrade
--- PASS: TestValidateRejectsMissingDegrade (0.00s)
=== RUN   TestValidateRejectsDuplicateName
--- PASS: TestValidateRejectsDuplicateName (0.00s)
=== RUN   TestValidateRejectsBadNameAndLimit
--- PASS: TestValidateRejectsBadNameAndLimit (0.00s)
=== RUN   TestCoverageCountsRequiredInterfaces
--- PASS: TestCoverageCountsRequiredInterfaces (0.00s)
=== RUN   TestCoverageIgnoresDuplicates
--- PASS: TestCoverageIgnoresDuplicates (0.00s)
=== RUN   TestCoverageDoesNotCountEmptyDegrade
--- PASS: TestCoverageDoesNotCountEmptyDegrade (0.00s)
=== RUN   TestCoverageEmptyRequiredIsZero
--- PASS: TestCoverageEmptyRequiredIsZero (0.00s)
PASS
ok  	webapp/internal/promo	0.341s