《互联网产品的服务端架构·交易、增长与平台化》7.3 增长实验的度量

// file: internal/growth/metrics.go
// tier: L1
// verify: go test ./internal/growth/

package growth

import (
	"errors"
	"fmt"
)

var (
	// ErrNoUsers 表示分组的用户数为零或负数，无法计算转化率。
	ErrNoUsers = errors.New("growth: group has no users")
	// ErrBadConverted 表示转化人数不在 0..Users 之间。
	ErrBadConverted = errors.New("growth: converted out of range")
	// ErrZeroControlRate 表示对照组转化率为零，相对提升没有定义。
	ErrZeroControlRate = errors.New("growth: control rate is zero")
)

// Group 是一个实验分组。Users 是进入分组的用户数，Converted 是在
// 观察窗口内完成目标行为的用户数。两个字段都按去重后的用户计。
type Group struct {
	Users     int
	Converted int
}

// Rate 返回分组的转化率。Users 必须大于零，Converted 必须落在
// 0..Users 之间；非法输入返回错误，而不是悄悄算出负数或超过 1 的值。
func Rate(g Group) (float64, error) {
	if g.Users <= 0 {
		return 0, fmt.Errorf("%w: users=%d", ErrNoUsers, g.Users)
	}
	if g.Converted < 0 || g.Converted > g.Users {
		return 0, fmt.Errorf("%w: converted=%d users=%d", ErrBadConverted, g.Converted, g.Users)
	}
	return float64(g.Converted) / float64(g.Users), nil
}

// Lift 返回实验组相对对照组的转化率相对提升：
//
//	(treatRate - controlRate) / controlRate
//
// 对照组转化率为零时相对提升没有定义，返回 ErrZeroControlRate。
// 任一组的计数非法时返回对应错误；两个入参都按值传递，不会被修改。
func Lift(control, treat Group) (float64, error) {
	controlRate, err := Rate(control)
	if err != nil {
		return 0, fmt.Errorf("control: %w", err)
	}
	treatRate, err := Rate(treat)
	if err != nil {
		return 0, fmt.Errorf("treat: %w", err)
	}
	if controlRate == 0 {
		return 0, ErrZeroControlRate
	}
	return (treatRate - controlRate) / controlRate, nil
}

// file: internal/growth/metrics_test.go
// tier: L1
// verify: go test ./internal/growth/

package growth

import (
	"errors"
	"math"
	"testing"
)

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

func TestRate(t *testing.T) {
	cases := []struct {
		name string
		g    Group
		want float64
	}{
		{"quarter", Group{Users: 100, Converted: 25}, 0.25},
		{"all", Group{Users: 40, Converted: 40}, 1},
		{"none", Group{Users: 40, Converted: 0}, 0},
	}
	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			got, err := Rate(c.g)
			if err != nil {
				t.Fatalf("Rate = %v, want nil", err)
			}
			if !almostEqual(got, c.want) {
				t.Fatalf("Rate = %v, want %v", got, c.want)
			}
		})
	}
}

func TestRateRejectsInvalidGroups(t *testing.T) {
	cases := []struct {
		name string
		g    Group
		want error
	}{
		{"zero-users", Group{Users: 0}, ErrNoUsers},
		{"negative-users", Group{Users: -1}, ErrNoUsers},
		{"negative-converted", Group{Users: 10, Converted: -1}, ErrBadConverted},
		{"converted-over-users", Group{Users: 10, Converted: 11}, ErrBadConverted},
	}
	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			if _, err := Rate(c.g); !errors.Is(err, c.want) {
				t.Fatalf("Rate = %v, want %v", err, c.want)
			}
		})
	}
}

func TestLift(t *testing.T) {
	cases := []struct {
		name    string
		control Group
		treat   Group
		want    float64
	}{
		{"positive", Group{Users: 100, Converted: 10}, Group{Users: 100, Converted: 12}, 0.2},
		{"negative", Group{Users: 100, Converted: 10}, Group{Users: 100, Converted: 8}, -0.2},
		{"flat", Group{Users: 50, Converted: 5}, Group{Users: 200, Converted: 20}, 0},
	}
	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			got, err := Lift(c.control, c.treat)
			if err != nil {
				t.Fatalf("Lift = %v, want nil", err)
			}
			if !almostEqual(got, c.want) {
				t.Fatalf("Lift = %v, want %v", got, c.want)
			}
		})
	}
}

func TestLiftRejectsZeroControl(t *testing.T) {
	control := Group{Users: 100, Converted: 0}
	treat := Group{Users: 100, Converted: 5}
	if _, err := Lift(control, treat); !errors.Is(err, ErrZeroControlRate) {
		t.Fatalf("Lift = %v, want ErrZeroControlRate", err)
	}
}

func TestLiftPropagatesGroupErrors(t *testing.T) {
	good := Group{Users: 100, Converted: 10}
	if _, err := Lift(Group{Users: 0}, good); !errors.Is(err, ErrNoUsers) {
		t.Fatalf("control error = %v, want ErrNoUsers", err)
	}
	if _, err := Lift(good, Group{Users: 10, Converted: 11}); !errors.Is(err, ErrBadConverted) {
		t.Fatalf("treat error = %v, want ErrBadConverted", err)
	}
}

func TestLiftDoesNotMutateGroups(t *testing.T) {
	control := Group{Users: 100, Converted: 10}
	treat := Group{Users: 100, Converted: 12}
	beforeControl, beforeTreat := control, treat
	if _, err := Lift(control, treat); err != nil {
		t.Fatalf("Lift = %v, want nil", err)
	}
	if control != beforeControl || treat != beforeTreat {
		t.Fatalf("inputs mutated: control=%+v treat=%+v", control, treat)
	}
}

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

=== RUN   TestRate
=== RUN   TestRate/quarter
=== RUN   TestRate/all
=== RUN   TestRate/none
--- PASS: TestRate (0.00s)
    --- PASS: TestRate/quarter (0.00s)
    --- PASS: TestRate/all (0.00s)
    --- PASS: TestRate/none (0.00s)
=== RUN   TestRateRejectsInvalidGroups
=== RUN   TestRateRejectsInvalidGroups/zero-users
=== RUN   TestRateRejectsInvalidGroups/negative-users
=== RUN   TestRateRejectsInvalidGroups/negative-converted
=== RUN   TestRateRejectsInvalidGroups/converted-over-users
--- PASS: TestRateRejectsInvalidGroups (0.00s)
    --- PASS: TestRateRejectsInvalidGroups/zero-users (0.00s)
    --- PASS: TestRateRejectsInvalidGroups/negative-users (0.00s)
    --- PASS: TestRateRejectsInvalidGroups/negative-converted (0.00s)
    --- PASS: TestRateRejectsInvalidGroups/converted-over-users (0.00s)
=== RUN   TestLift
=== RUN   TestLift/positive
=== RUN   TestLift/negative
=== RUN   TestLift/flat
--- PASS: TestLift (0.00s)
    --- PASS: TestLift/positive (0.00s)
    --- PASS: TestLift/negative (0.00s)
    --- PASS: TestLift/flat (0.00s)
=== RUN   TestLiftRejectsZeroControl
--- PASS: TestLiftRejectsZeroControl (0.00s)
=== RUN   TestLiftPropagatesGroupErrors
--- PASS: TestLiftPropagatesGroupErrors (0.00s)
=== RUN   TestLiftDoesNotMutateGroups
--- PASS: TestLiftDoesNotMutateGroups (0.00s)
PASS
ok  	webapp/internal/growth	0.287s