Go语言mgo.Database单元测试：利用接口实现依赖注入与Mock

package main

import (
    "fmt"
    "gopkg.in/mgo.v2"
    "gopkg.in/mgo.v2/bson"
)

// 原始函数签名，直接依赖 *mgo.Database
func myFunc(db *mgo.Database, id string) (string, error) {
    collection := db.C("my_collection")
    var result struct {
        Name string `bson:"name"`
    }
    err := collection.Find(bson.M{"_id": id}).One(&result)
    if err != nil {
        return "", err
    }
    return result.Name, nil
}

// 定义一个用于模拟mgo.Query的接口
type Queryer interface {
    One(result interface{}) error
}

// 定义一个用于模拟mgo.Collection的接口
type Collectioner interface {
    Find(query interface{}) Queryer
}

// 定义一个用于模拟mgo.Database的接口
type DBConnector interface {
    C(name string) Collectioner
}

// 修改后的函数签名，依赖 DBConnector 接口
func myFunc(db DBConnector, id string) (string, error) {
    collection := db.C("my_collection")
    var result struct {
        Name string `bson:"name"`
    }
    err := collection.Find(bson.M{"_id": id}).One(&result)
    if err != nil {
        return "", err
    }
    return result.Name, nil
}

// MockQuery 实现了 Queryer 接口
type MockQuery struct {
    Result interface{}
    Err    error
}

func (mq *MockQuery) One(result interface{}) error {
    if mq.Err != nil {
        return mq.Err
    }
    // 模拟数据拷贝
    if mq.Result != nil {
        // 这里需要一个更健壮的深拷贝机制，简单示例用反射或json序列化/反序列化
        // 实际项目中，通常会直接将mq.Result赋值给result指向的内存
        // 为了简化示例，我们假设result是指针，直接赋值其指向的值
        // 或者，更安全地，通过json序列化/反序列化进行深拷贝
        // 示例中直接将mq.Result赋给result，假设类型兼容
        if ptr, ok := result.(*struct{ Name string }); ok {
            if res, ok := mq.Result.(struct{ Name string }); ok {
                *ptr = res
            }
        }
    }
    return nil
}

// MockCollection 实现了 Collectioner 接口
type MockCollection struct {
    MockQuery *MockQuery
}

func (mc *MockCollection) Find(query interface{}) Queryer {
    // 在这里可以根据query参数进行更复杂的模拟逻辑
    // 例如，检查query是否符合预期，然后返回不同的MockQuery
    return mc.MockQuery
}

// MockDatabase 实现了 DBConnector 接口
type MockDatabase struct {
    MockCollection *MockCollection
}

func (md *MockDatabase) C(name string) Collectioner {
    // 同样，可以根据collection name返回不同的MockCollection
    return md.MockCollection
}

package main

import (
    "errors"
    "testing"
)

func TestMyFunc(t *testing.T) {
    tests := []struct {
        name     string
        inputID  string
        mockData struct {
            Name string `bson:"name"`
        }
        mockErr  error
        expected string
        err      error
    }{
        {
            name:    "成功获取数据",
            inputID: "123",
            mockData: struct {
                Name string `bson:"name"`
            }{Name: "TestUser"},
            mockErr:  nil,
            expected: "TestUser",
            err:      nil,
        },
        {
            name:    "数据未找到",
            inputID: "456",
            mockData: struct {
                Name string `bson:"name"`
            }{}, // 模拟未找到数据
            mockErr:  errors.New("not found"), // mgo.ErrNotFound
            expected: "",
            err:      errors.New("not found"),
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            // 构建模拟对象链
            mockQuery := &MockQuery{
                Result: tt.mockData,
                Err:    tt.mockErr,
            }
            mockCollection := &MockCollection{
                MockQuery: mockQuery,
            }
            mockDB := &MockDatabase{
                MockCollection: mockCollection,
            }

            // 调用被测试函数
            got, err := myFunc(mockDB, tt.inputID)

            // 验证结果
            if (err != nil && tt.err == nil) || (err == nil && tt.err != nil) || (err != nil && tt.err != nil && err.Error() != tt.err.Error()) {
                t.Errorf("myFunc() error = %v, wantErr %v", err, tt.err)
                return
            }
            if got != tt.expected {
                t.Errorf("myFunc() got = %v, want %v", got, tt.expected)
            }
        })
    }
}