如何避免在多包测试中重复编写日志依赖初始化代码？

1. 在日志包装器包中封装测试辅助函数 #

直接把重复的日志初始化逻辑封装到logger包的公开函数里，其他包的测试直接调用就行，不用再重复写一遍。

示例代码（logger/testhelpers.go）：

package logger

import (
	"io"
	"github.com/sirupsen/logrus"
)

// SetupTestLogger 返回适配测试场景的Logger实例
// 配置为丢弃输出（避免干扰测试控制台），日志级别设为Debug
func SetupTestLogger() Logger {
	logrusLogger := logrus.New()
	logrusLogger.SetOutput(io.Discard) // 也可以换成bytes.Buffer，方便后续断言日志内容
	logrusLogger.SetLevel(logrus.DebugLevel)
	// 这里可以加测试专用配置，比如禁用颜色、设置简洁格式等
	return NewLogrusLogger(logrusLogger) // 用你自己的包装函数把logrus实例转成自定义Logger
}

其他包测试时直接调用：

package somepackage

import (
	"testing"
	"yourproject/logger"
)

func TestSomeFunction(t *testing.T) {
	testLogger := logger.SetupTestLogger()
	// 把testLogger注入到要测试的组件里
	component := NewComponent(testLogger)
	// 执行测试逻辑
}

2. 用Mock Logger替代真实实例（可选） #

如果测试不需要真的输出日志，只是要验证日志是否被正确调用，可以给Logger接口写个Mock实现，放到logger包里供测试用。

示例代码（logger/mock_logger.go）：

package logger

import (
	"sync"
)

// MockLogger 是Logger接口的测试实现，用来记录所有日志调用
type MockLogger struct {
	mu      sync.Mutex
	entries []LogEntry
}

type LogEntry struct {
	Level   string
	Message string
	Fields  map[string]interface{}
}

// 实现Logger接口的所有方法，比如Debug/Info/Warn/Error等
func (m *MockLogger) Debug(msg string, fields ...interface{}) {
	m.log("debug", msg, fields)
}

func (m *MockLogger) log(level, msg string, fields []interface{}) {
	m.mu.Lock()
	defer m.mu.Unlock()
	entry := LogEntry{
		Level:   level,
		Message: msg,
		Fields:  make(map[string]interface{}),
	}
	// 解析fields的键值对（假设传入的是key-value交替的参数）
	for i := 0; i < len(fields); i += 2 {
		if i+1 >= len(fields) {
			break
		}
		key, ok := fields[i].(string)
		if !ok {
			continue
		}
		entry.Fields[key] = fields[i+1]
	}
	m.entries = append(m.entries, entry)
}

// GetEntries 返回所有记录的日志，用于测试断言
func (m *MockLogger) GetEntries() []LogEntry {
	m.mu.Lock()
	defer m.mu.Unlock()
	// 返回副本防止并发修改
	entries := make([]LogEntry, len(m.entries))
	copy(entries, m.entries)
	return entries
}

// NewMockLogger 创建新的MockLogger实例
func NewMockLogger() *MockLogger {
	return &MockLogger{
		entries: []LogEntry{},
	}
}

测试时用MockLogger还能验证日志内容：

func TestComponentLogsError(t *testing.T) {
	mockLogger := logger.NewMockLogger()
	component := NewComponent(mockLogger)
	
	component.DoSomethingThatLogsError()
	
	entries := mockLogger.GetEntries()
	if len(entries) == 0 {
		t.Error("预期会输出错误日志，但没有记录到")
	}
	if entries[0].Level != "error" {
		t.Errorf("预期日志级别是error，实际是%s", entries[0].Level)
	}
}

3. 单包内用TestMain统一初始化（Go 1.14+） #

如果某个包的所有测试用例都用同一个日志实例，可以在该包的测试文件里用TestMain做一次性初始化，包内所有测试直接用全局变量。

示例代码（somepackage/somepackage_test.go）：

package somepackage

import (
	"os"
	"testing"
	"yourproject/logger"
)

var testLogger logger.Logger

func TestMain(m *testing.M) {
	// 全局初始化日志
	testLogger = logger.SetupTestLogger()
	// 运行当前包所有测试
	os.Exit(m.Run())
}

func TestFunction1(t *testing.T) {
	component := NewComponent(testLogger)
	// 测试逻辑
}

func TestFunction2(t *testing.T) {
	component := NewComponent(testLogger)
	// 测试逻辑
}

这种方式适合单个包内多个测试共享日志实例的场景，不用每个测试函数都重复初始化。

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