重构工单一半在改测试？你的测试绑太死了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 测实现：知道内部调了 A 再调 B
func TestProcess(t *testing.T) {
    mockA := new(MockA)
    mockB := new(MockB)
    svc := NewService(mockA, mockB)
    svc.Process(ctx, req)
    mockA.AssertExpectations(t)
    mockB.AssertExpectations(t)
    // 重构后：排序变了、参数变了——全炸
}

// 测行为：知道输入 X 得到输出 Y
func TestProcess(t *testing.T) {
    svc := NewService(realA, realB)
    got := svc.Process(ctx, req)
    assert.Equal(t, expected, got)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func TestRender(t *testing.T) {
    got := Render(input)
    golden := filepath.Join("testdata", t.Name()+".golden")
    if *update {
        os.WriteFile(golden, got, 0644)
    }
    expected, _ := os.ReadFile(golden)
    if string(expected) != string(got) {
        t.Fatalf("got != golden\n%s", diff.Text(expected, got))
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 在 repository 层定义完整接口
type UserRepo interface {
    Get(ctx, id)
    Save(ctx, u)
    Delete(ctx, id)
    List(ctx, filter)
}

// 在调用方定义刚好够用的接口
type UserGetter interface {
    Get(ctx, id) (*User, error)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

func TestSortedUsersByAge(t *testing.T) {
    users := []User{{"A", 30}, {"B", 25}, {"C", 30}}
    result := SortByAge(users)

    // 性质：年龄非递减
    for i := 1; i < len(result); i++ {
        if result[i].Age < result[i-1].Age {
            t.Fatal("not sorted by age")
        }
    }

    // 性质：元素数量不变
    if len(result) != len(users) {
        t.Fatal("lost users")
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

func TestParseConfig(t *testing.T) {
    tests := []struct {
        name  string
        input string
        want  Config
    }{
        {"基本字段", `{"host": "localhost"}`, Config{Host: "localhost"}},
        {"默认值填充", `{}`, Config{Host: "default", Port: 8080}},
        {"未知字段忽略", `{"host":"x","unknown":"y"}`, Config{Host: "x", Port: 8080}},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := ParseConfig(tt.input)
            if !reflect.DeepEqual(got, tt.want) {
                t.Fatalf("got %+v, want %+v", got, tt.want)
            }
        })
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func FuzzParseConfig(f *testing.F) {
    f.Fuzz(func(t *testing.T, input string) {
        cfg := ParseConfig(input)
        if cfg.Port != 0 {
            if cfg.Port < 1 || cfg.Port > 65535 {
                t.Errorf("port out of range: %d", cfg.Port)
            }
        }
    })
}

1
2
3
4
5

func BenchmarkProcess(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Process(bigInput)
    }
}