Go新手求助：如何让函数接收不同结构体并为S3上传器创建Mock对象

嘿，作为Go新手碰到结构体和接口的困惑太正常了，我来一步步帮你解决这两个问题！

首先咱们先补全你没写完的GetS3Uploader函数（应该是创建s3manager的实例）：

func GetS3Uploader() *s3manager.Uploader {
    conf := aws.Config{Region: aws.String("eu-west-1")}
    sess := session.New(&conf)
    return s3manager.NewUploader(sess)
}

要Mock这个Uploader，核心思路是依赖接口而非具体类型——因为Go的接口是隐式实现的，我们只需要定义一个包含Upload方法的接口，让真实的s3manager.Uploader和我们的Mock结构体都实现它。

步骤1：定义Uploader接口 #

在你的uploader包中添加一个接口，匹配s3manager.Uploader的核心方法：

package uploader

import "github.com/aws/aws-sdk-go/service/s3/s3manager"

// S3Uploader 定义Uploader的核心行为接口
type S3Uploader interface {
    Upload(input *s3manager.UploadInput, options ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error)
}

然后修改GetS3Uploader的返回类型为这个接口（真实的s3manager.Uploader已经实现了这个接口，所以不需要额外代码）：

func GetS3Uploader() S3Uploader {
    conf := aws.Config{Region: aws.String("eu-west-1")}
    sess := session.New(&conf)
    return s3manager.NewUploader(sess)
}

步骤2：编写Mock结构体 #

创建一个Mock结构体，让它实现S3Uploader接口，并且允许我们自定义Upload方法的行为：

import "fmt"

// MockS3Uploader 用于单元测试的Mock Uploader
type MockS3Uploader struct {
    // 用一个函数变量来模拟Upload的行为
    UploadFunc func(input *s3manager.UploadInput, options ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error)
}

// Upload 实现S3Uploader接口
func (m *MockS3Uploader) Upload(input *s3manager.UploadInput, options ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error) {
    if m.UploadFunc != nil {
        return m.UploadFunc(input, options...)
    }
    return nil, fmt.Errorf("mock Upload method not implemented")
}

步骤3：在单元测试中使用Mock #

比如你有一个依赖Uploader的业务函数UploadFileToS3，现在可以传入Mock来测试：

import "testing"

func TestUploadFileToS3(t *testing.T) {
    // 创建Mock并自定义Upload行为
    mockUploader := &MockS3Uploader{
        UploadFunc: func(input *s3manager.UploadInput, options ...func(*s3manager.Uploader)) (*s3manager.UploadOutput, error) {
            // 断言输入参数是否符合预期
            expectedBucket := "test-bucket"
            if aws.StringValue(input.Bucket) != expectedBucket {
                t.Errorf("expected bucket %q, got %q", expectedBucket, aws.StringValue(input.Bucket))
            }
            // 返回模拟的成功结果
            return &s3manager.UploadOutput{
                Location: aws.String("https://test-bucket.s3.eu-west-1.amazonaws.com/test-file.txt"),
            }, nil
        },
    }

    // 调用业务函数，传入Mock
    err := UploadFileToS3(mockUploader, "test-file.txt")
    if err != nil {
        t.Fatalf("unexpected error: %v", err)
    }
}

这样就能脱离真实的AWS环境，单独测试你的业务逻辑啦！

Go里处理多类型输入主要有三种方案，按推荐优先级排序：

1. 优先使用接口（最符合Go的设计哲学） #

如果你的不同结构体有共同的行为，定义一个包含该行为的接口，让结构体实现这个接口，函数接受接口类型即可。

比如，假设你有User和Product两个结构体，都需要被“导出”：

import (
    "encoding/json"
    "fmt"
    "os"
    "reflect"
)

// Exportable 定义导出行为的接口
type Exportable interface {
    Export() ([]byte, error)
}

// 接受Exportable接口的函数
func ExportData(e Exportable) error {
    data, err := e.Export()
    if err != nil {
        return err
    }
    // 处理导出的数据
    return os.WriteFile(fmt.Sprintf("%s.json", reflect.TypeOf(e).Name()), data, 0644)
}

// User结构体实现Exportable
type User struct {
    ID   int
    Name string
}

func (u *User) Export() ([]byte, error) {
    return json.Marshal(u)
}

// Product结构体实现Exportable
type Product struct {
    SKU  string
    Name string
}

func (p *Product) Export() ([]byte, error) {
    return json.Marshal(p)
}

现在ExportData函数可以接受*User和*Product作为输入了。

2. 使用泛型（Go 1.18+） #

如果你的不同结构体没有共同行为，但有相似的处理逻辑，可以用泛型来实现通用函数。

比如，一个打印结构体名称的通用函数：

import "reflect"

// PrintTypeName 接受任意类型的输入，打印其类型名称
func PrintTypeName[T any](input T) {
    fmt.Println("Type name:", reflect.TypeOf(input).Name())
}

// 使用示例
PrintTypeName(User{ID:1, Name:"Alice"}) // 输出 Type name: User
PrintTypeName(Product{SKU:"123", Name:"Laptop"}) // 输出 Type name: Product

还可以给泛型加约束，比如只允许包含Name字段的结构体：

// HasName 约束结构体必须有Name字段
type HasName interface {
    ~struct{ Name string } // ~表示包含该字段的结构体类型（包括自定义的）
}

func PrintName[T HasName](input T) {
    fmt.Println("Name:", input.Name)
}

// 这样User和Product都可以传入
PrintName(User{Name:"Alice"}) // 输出 Name: Alice
PrintName(Product{Name:"Laptop"}) // 输出 Name: Laptop

3. 使用空接口interface{}（兜底方案） #

如果以上两种都不适用，可以用空接口接受任意类型，然后通过类型断言或类型switch来处理不同类型。但这种方式会丢失类型安全，尽量少用。

示例：

import "fmt"

func HandleInput(input interface{}) error {
    switch v := input.(type) {
    case User:
        fmt.Println("Handling User:", v.Name)
    case Product:
        fmt.Println("Handling Product:", v.SKU)
    default:
        return fmt.Errorf("unsupported type: %T", input)
    }
    return nil
}

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