如何在Golang测试失败时捕获额外上下文？（基于testing标准库）

针对你的需求，有两个可行的hack方案，不需要修改现有测试代码、替换测试库或重写go test逻辑：

方案1：反射替换testing.T的失败相关方法 #

testing.T的所有失败相关方法（如Fail、FailNow、Errorf、Fatalf）最终都会调用底层的失败标记逻辑。我们可以通过反射和unsafe包，将这些方法替换为自定义的包装函数，在执行原方法后触发你的通用通知逻辑。

示例代码：

package your_test_package

import (
	"reflect"
	"testing"
	"unsafe"
)

// 保存原方法的函数指针
var (
	originalFail    func(*testing.T)
	originalFailNow func(*testing.T)
)

// 自定义失败处理逻辑
func handleTestFailure() {
	// 替换为你的实际需求：通知其他系统、记录额外上下文等
	println("测试失败，触发通用处理逻辑")
}

// 包装后的Fail方法
func wrappedFail(t *testing.T) {
	originalFail(t)
	handleTestFailure()
}

// 包装后的FailNow方法
func wrappedFailNow(t *testing.T) {
	originalFailNow(t)
	handleTestFailure()
}

func init() {
	tType := reflect.TypeOf(&testing.T{})

	// 替换Fail方法
	if failMethod, ok := tType.MethodByName("Fail"); ok {
		originalFail = *(*func(*testing.T))(unsafe.Pointer(&failMethod.Func))
		newFunc := reflect.MakeFunc(failMethod.Type, func(args []reflect.Value) []reflect.Value {
			t := args[0].Interface().(*testing.T)
			wrappedFail(t)
			return nil
		})
		*(*reflect.Value)(unsafe.Pointer(&failMethod.Func)) = newFunc
	}

	// 替换FailNow方法（处理t.Fatalf这类会终止测试的调用）
	if failNowMethod, ok := tType.MethodByName("FailNow"); ok {
		originalFailNow = *(*func(*testing.T))(unsafe.Pointer(&failNowMethod.Func))
		newFunc := reflect.MakeFunc(failNowMethod.Type, func(args []reflect.Value) []reflect.Value {
			t := args[0].Interface().(*testing.T)
			wrappedFailNow(t)
			return nil
		})
		*(*reflect.Value)(unsafe.Pointer(&failNowMethod.Func)) = newFunc
	}
}

这个方案的优势是实时触发，测试失败的瞬间就会执行你的逻辑；缺点是依赖Go标准库的内部实现，不同Go版本可能存在兼容性问题（比如testing.T的方法签名或内部结构变化）。

方案2：通过反射给所有测试添加Cleanup钩子 #

testing.T内部有一个私有字段common，其中包含cleanups切片，用于存储测试结束时执行的清理函数。我们可以通过反射给每个*testing.T实例添加一个清理函数，在测试结束时检查是否失败，再执行通用逻辑。

示例代码：

package your_test_package

import (
	"reflect"
	"testing"
	"unsafe"
)

// 自定义失败处理逻辑
func handleTestFailure(t *testing.T) {
	if t.Failed() {
		// 替换为你的实际需求
		println("测试", t.Name(), "失败，触发通用处理逻辑")
	}
}

func init() {
	// 替换testing.T的Run方法，给每个子测试添加Cleanup
	tType := reflect.TypeOf(&testing.T{})
	if runMethod, ok := tType.MethodByName("Run"); ok {
		originalRun := runMethod.Func
		newRun := reflect.MakeFunc(runMethod.Type, func(args []reflect.Value) []reflect.Value {
			t := args[0].Interface().(*testing.T)
			// 给当前测试添加Cleanup钩子
			addCleanup(t, func() { handleTestFailure(t) })
			// 调用原Run方法
			return originalRun.Call(args)
		})
		*(*reflect.Value)(unsafe.Pointer(&runMethod.Func)) = newRun
	}
}

// 反射添加Cleanup函数
func addCleanup(t *testing.T, fn func()) {
	// 获取t的common字段
	commonField := reflect.ValueOf(t).Elem().FieldByName("common")
	if !commonField.IsValid() {
		panic("无法获取common字段")
	}
	// 获取cleanups切片
	cleanupsField := commonField.FieldByName("cleanups")
	if !cleanupsField.IsValid() {
		panic("无法获取cleanups字段")
	}
	// 将fn添加到cleanups切片
	cleanups := cleanupsField.Slice(0, cleanupsField.Len()).Interface().([]func())
	cleanups = append(cleanups, fn)
	cleanupsField.Set(reflect.ValueOf(cleanups))
}

// 定义TestMain确保顶层测试的失败也能被处理
func TestMain(m *testing.M) {
	// 给顶层测试添加Cleanup钩子（可结合方案1的Fail方法替换实现）
	// 执行测试
	m.Run()
}

这个方案的优势是更贴近testing库的原生机制，清理函数会在测试结束时可靠执行；缺点同样是依赖内部字段结构，版本兼容性需要验证。

注意事项 #

• 这两个方案都属于hack，依赖Go标准库的未公开实现，升级Go版本时需要重新验证兼容性。
• 可以根据实际需求，选择只替换关键方法（如Fail和FailNow），因为Errorf、Fatalf等方法最终都会调用这两个底层方法。

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