Go语言应用测试组织与循环引用规避指南

myapp/
├── controllers/
│   └── account.go
├── models/
│   ├── account.go
│   └── account_test.go
├── components/
│   └── comp1/
│       ├── impl.go
│       └── impl_test.go
└── testutil/
    ├── database.go
    └── models.go // 包含模型相关的测试辅助函数

// myapp/models/account.go
package models

type Account struct {
    ID   int
    Name string
}

func GetAccountByID(id int) (*Account, error) {
    // 实际业务逻辑
    return &Account{ID: id, Name: "Test Account"}, nil
}

// myapp/models/testutils_test.go (与account.go同属models包)
package models

import (
    "testing"
    "fmt"
    // 可以直接使用models包内的类型和函数，无循环引用风险
)

// setupTestDB 模拟数据库初始化，为models包的测试提供环境
func setupTestDB(t *testing.T) {
    t.Helper() // 标记为辅助函数
    fmt.Println("Setting up test database for models package...")
    // 假设这里会用到models包的Account类型进行初始化
    _ = &Account{ID: 1, Name: "Temp"} // 示例使用Account类型
    // ... 实际数据库初始化逻辑 ...
}

// createTestAccount 创建一个测试账户
func createTestAccount(t *testing.T, id int, name string) *Account {
    t.Helper()
    fmt.Printf("Creating test account ID: %d, Name: %s\n", id, name)
    return &Account{ID: id, Name: name}
}

// myapp/models/account_test.go (与account.go同属models包)
package models

import (
    "testing"
    "reflect"
)

func TestGetAccountByID(t *testing.T) {
    setupTestDB(t) // 调用models包内部的测试辅助函数

    expectedAccount := createTestAccount(t, 1, "Test Account")

    account, err := GetAccountByID(1)
    if err != nil {
        t.Fatalf("GetAccountByID failed: %v", err)
    }
    if !reflect.DeepEqual(account, expectedAccount) {
        t.Errorf("Expected %v, got %v", expectedAccount, account)
    }
}

// myapp/components/comp1/impl.go
package comp1

import "fmt"

type Client struct {
    // 客户端连接等
}

func NewClient() *Client {
    fmt.Println("Initializing comp1 client...")
    return &Client{}
}

func (c *Client) DoSomething() string {
    return "Comp1 did something"
}

// myapp/components/comp1/impl_test.go
package comp1

import (
    "testing"
    "os"
)

var testClient *Client

// init() 函数会在包被导入（即测试运行前）时自动执行
// 适合简单的、一次性的初始化
func init() {
    testClient = NewClient()
    if testClient == nil {
        panic("Failed to initialize comp1 client for tests")
    }
    fmt.Println("comp1 test client initialized via init()")
}

// TestMain 函数提供更细粒度的测试生命周期控制
// 可以在所有测试运行前执行 setup，并在所有测试运行后执行 teardown
// func TestMain(m *testing.M) {
//     fmt.Println("TestMain: Setting up comp1 test environment...")
//     testClient = NewClient()
//     if testClient == nil {
//         fmt.Println("Failed to initialize comp1 client in TestMain")
//         os.Exit(1)
//     }
//     
//     code := m.Run() // 运行所有测试
//     
//     fmt.Println("TestMain: Tearing down comp1 test environment...")
//     // 清理资源，例如关闭连接
//     
//     os.Exit(code)
// }

func TestComp1Functionality(t *testing.T) {
    if testClient == nil {
        t.Fatal("Test client was not initialized")
    }
    result := testClient.DoSomething()
    expected := "Comp1 did something"
    if result != expected {
        t.Errorf("Expected %q, got %q", expected, result)
    }
}