使用errors.As()遍历测试结构体时遇参数不应为*error的问题

问题原因 #

你遇到的second argument to errors.As should not be *error错误，本质是errors.As的参数要求：第二个参数必须是指向具体错误类型的指针（即*T，其中T实现error接口），而不是指向error接口的指针（*error）。

当你把测试结构体的err字段改成interface{}后断言全通过，是因为直接将&interface{}传给errors.As时，它无法正确匹配具体错误类型，导致断言逻辑失效。

解决方案 #

下面提供两种实用的解决方式，适配不同的测试场景：

方案一：按错误类型分支匹配（适合类型较少的场景） #

先定义你的自定义错误类型（示例）：

type ValidationError struct {
    Field string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("invalid field: %s", e.Field)
}

type NotFoundError struct {
    ID string
}

func (e *NotFoundError) Error() string {
    return fmt.Sprintf("resource %s not found", e.ID)
}

测试用例结构体和测试函数：

type testCase struct {
    name      string
    input     string
    wantErr   bool
    errType   interface{} // 存储期望的错误类型实例，如&ValidationError{}
}

func TestMyFunc(t *testing.T) {
    cases := []testCase{
        {
            name:    "empty input",
            input:   "",
            wantErr: true,
            errType: &ValidationError{},
        },
        {
            name:    "unknown ID",
            input:   "123",
            wantErr: true,
            errType: &NotFoundError{},
        },
        {
            name:    "valid input",
            input:   "valid_001",
            wantErr: false,
        },
    }

    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            _, err := MyFunc(tc.input)

            if tc.wantErr {
                if err == nil {
                    t.Fatal("expected error, got nil")
                }

                // 根据期望的错误类型，创建对应类型的变量并匹配
                switch tc.errType.(type) {
                case *ValidationError:
                    var ve *ValidationError
                    if !errors.As(err, &ve) {
                        t.Fatalf("expected ValidationError, got %T", err)
                    }
                    // 可选：断言错误字段
                    if ve.Field != "input" {
                        t.Errorf("expected field 'input', got %s", ve.Field)
                    }
                case *NotFoundError:
                    var nfe *NotFoundError
                    if !errors.As(err, &nfe) {
                        t.Fatalf("expected NotFoundError, got %T", err)
                    }
                default:
                    t.Fatalf("unsupported error type: %T", tc.errType)
                }
            } else {
                if err != nil {
                    t.Fatalf("unexpected error: %v", err)
                }
            }
        })
    }
}

方案二：使用断言函数（适合复杂或多字段的错误断言） #

这种方式更灵活，能同时校验错误类型和字段细节：

type testCase struct {
    name      string
    input     string
    wantErr   bool
    assertErr func(error) bool // 自定义断言逻辑
}

func TestMyFunc(t *testing.T) {
    cases := []testCase{
        {
            name:    "empty input",
            input:   "",
            wantErr: true,
            assertErr: func(err error) bool {
                var ve *ValidationError
                if errors.As(err, &ve) {
                    return ve.Field == "input"
                }
                return false
            },
        },
        {
            name:    "unknown ID",
            input:   "123",
            wantErr: true,
            assertErr: func(err error) bool {
                var nfe *NotFoundError
                if errors.As(err, &nfe) {
                    return nfe.ID == "123"
                }
                return false
            },
        },
        {
            name:    "valid input",
            input:   "valid_001",
            wantErr: false,
        },
    }

    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            _, err := MyFunc(tc.input)

            if tc.wantErr {
                if err == nil {
                    t.Fatal("expected error, got nil")
                }
                if !tc.assertErr(err) {
                    t.Fatalf("error does not match expectation: %v", err)
                }
            } else {
                if err != nil {
                    t.Fatalf("unexpected error: %v", err)
                }
            }
        })
    }
}

关键注意点 #

• 永远不要把*error传给errors.As的第二个参数，必须传具体错误类型的指针（如&ValidationError{}）。
• 如果你的错误是被包装过的（比如用fmt.Errorf("wrap: %w", err)），必须用errors.As来解包匹配，不能直接用reflect.TypeOf(err)比较。

内容的提问来源于stack exchange，提问作者anthonyoliai