《互联网产品的服务端架构·规模化与架构演进》8.3 平台采纳与反悔成本

// file: internal/pipeline/adoption.go
// tier: L1
// verify: go test ./internal/pipeline/

package pipeline

import (
	"fmt"
	"math"
)

// Adoption 是平台采纳进度的快照。
// Total 是纳入本次迁移范围的服务或工作负载数量，Migrated 是已经切过去的数量。
type Adoption struct {
	Migrated int
	Total    int
}

// Rate 返回迁移覆盖率，取值 [0,1]。
// 它拒绝“没有范围”和“数字互相矛盾”的输入，因为这两种情况都会让
// 使用率报表看起来很好，却无法指导下一步决策。
func Rate(a Adoption) (float64, error) {
	if a.Total <= 0 {
		return 0, fmt.Errorf("pipeline: total must be positive, got %d", a.Total)
	}
	if a.Migrated < 0 || a.Migrated > a.Total {
		return 0, fmt.Errorf("pipeline: migrated %d out of range [0,%d]", a.Migrated, a.Total)
	}
	return float64(a.Migrated) / float64(a.Total), nil
}

// ShouldAdopt 判断是否值得继续推进平台采纳。
//
// 两个条件必须同时成立：
//   - 覆盖率严格超过一半。低于一半时，双轨成本还在，规模收益尚未出现；
//   - 收益严格大于成本。相等意味着这笔投入没有回报，只消耗了迁移窗口。
//
// 非法覆盖率（NaN、负数、大于 1）一律返回 false：宁可停在原地，
// 也不要用一个算错的比例去驱动组织级决策。
func ShouldAdopt(rate float64, cost, benefit int64) bool {
	if math.IsNaN(rate) || rate <= 0.5 || rate > 1 {
		return false
	}
	if cost < 0 || benefit < 0 {
		return false
	}
	return benefit > cost
}

// file: internal/pipeline/adoption_test.go
// tier: L1
// verify: go test ./internal/pipeline/

package pipeline

import (
	"math"
	"testing"
)

func TestRate(t *testing.T) {
	cases := []struct {
		name string
		a    Adoption
		want float64
	}{
		{"none", Adoption{Migrated: 0, Total: 10}, 0},
		{"half", Adoption{Migrated: 5, Total: 10}, 0.5},
		{"three-quarters", Adoption{Migrated: 30, Total: 40}, 0.75},
		{"all", Adoption{Migrated: 10, Total: 10}, 1},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			got, err := Rate(tc.a)
			if err != nil {
				t.Fatalf("Rate(%+v): %v", tc.a, err)
			}
			if got != tc.want {
				t.Fatalf("Rate(%+v) = %v, want %v", tc.a, got, tc.want)
			}
		})
	}
}

func TestRateRejectsBadCounts(t *testing.T) {
	for _, a := range []Adoption{
		{Migrated: 0, Total: 0},
		{Migrated: 1, Total: -3},
		{Migrated: -1, Total: 10},
		{Migrated: 11, Total: 10},
	} {
		if _, err := Rate(a); err == nil {
			t.Fatalf("Rate(%+v): want error", a)
		}
	}
}

func TestShouldAdopt(t *testing.T) {
	cases := []struct {
		name    string
		rate    float64
		cost    int64
		benefit int64
		want    bool
	}{
		{"just-past-half", 0.51, 100, 101, true},
		{"exactly-half", 0.5, 100, 1000, false},
		{"below-half", 0.4, 100, 1000, false},
		{"benefit-equals-cost", 0.8, 100, 100, false},
		{"benefit-below-cost", 0.8, 100, 99, false},
		{"full-rate", 1.0, 0, 1, true},
		{"rate-above-one", 1.2, 0, 1000, false},
		{"nan-rate", math.NaN(), 0, 1000, false},
		{"negative-cost", 0.9, -1, 1000, false},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			if got := ShouldAdopt(tc.rate, tc.cost, tc.benefit); got != tc.want {
				t.Fatalf("ShouldAdopt(%v,%d,%d) = %v, want %v",
					tc.rate, tc.cost, tc.benefit, got, tc.want)
			}
		})
	}
}

cd .local/checks/webapp-lab && go test ./internal/pipeline/ -run 'TestRate|TestShouldAdopt' -count=1 -v

=== RUN   TestRate
=== RUN   TestRate/none
=== RUN   TestRate/half
=== RUN   TestRate/three-quarters
=== RUN   TestRate/all
--- PASS: TestRate (0.00s)
    --- PASS: TestRate/none (0.00s)
    --- PASS: TestRate/half (0.00s)
    --- PASS: TestRate/three-quarters (0.00s)
    --- PASS: TestRate/all (0.00s)
=== RUN   TestRateRejectsBadCounts
--- PASS: TestRateRejectsBadCounts (0.00s)
=== RUN   TestShouldAdopt
=== RUN   TestShouldAdopt/just-past-half
=== RUN   TestShouldAdopt/exactly-half
=== RUN   TestShouldAdopt/below-half
=== RUN   TestShouldAdopt/benefit-equals-cost
=== RUN   TestShouldAdopt/benefit-below-cost
=== RUN   TestShouldAdopt/full-rate
=== RUN   TestShouldAdopt/rate-above-one
=== RUN   TestShouldAdopt/nan-rate
=== RUN   TestShouldAdopt/negative-cost
--- PASS: TestShouldAdopt (0.00s)
    --- PASS: TestShouldAdopt/just-past-half (0.00s)
    --- PASS: TestShouldAdopt/exactly-half (0.00s)
    --- PASS: TestShouldAdopt/below-half (0.00s)
    --- PASS: TestShouldAdopt/benefit-equals-cost (0.00s)
    --- PASS: TestShouldAdopt/benefit-below-cost (0.00s)
    --- PASS: TestShouldAdopt/full-rate (0.00s)
    --- PASS: TestShouldAdopt/rate-above-one (0.00s)
    --- PASS: TestShouldAdopt/nan-rate (0.00s)
    --- PASS: TestShouldAdopt/negative-cost (0.00s)
PASS
ok  	webapp/internal/pipeline	0.382s