Go语言如何mock net.Interface实现net.Interfaces()固定返回用于单元测试

你当前的测试思路没有问题，核心阻碍是标准库的net.Interface为结构体类型，其绑定的Addrs方法无法直接重写，只需要对原有业务代码做极小的无侵入调整即可完成测试。

方案1：最小改动打桩（推荐快速适配现有代码） #

不需要重构整体逻辑，仅新增可替换的函数入口即可实现全场景mock。

步骤1：调整业务代码 #

const InterfaceWlan = "wlan0"
const InterfaceEthernet = "eth0"

var netInterfaces = net.Interfaces
// 新增：获取网卡地址的可替换变量，默认调用原生Addrs方法
var getInterfaceAddrs = func(i net.Interface) ([]net.Addr, error) {
    return i.Addrs()
}

func GetIpAddress() (net.IP, error) {
    ifaces, err := netInterfaces()
    if err != nil {
        return nil, err
    }

    for _, i := range ifaces {
        if i.Name == InterfaceWlan || i.Name == InterfaceEthernet {
            // 将原来的i.Addrs()替换为可mock的变量调用
            addrs, err := getInterfaceAddrs(i)
            // 原有addrs处理逻辑保持不变
        }
    }

    return nil, errors.New("network: ip not found")
}

步骤2：编写测试用例 #

测试时同时mock两个函数入口，测试完成后用defer恢复原函数，避免影响其他测试用例：

func TestGetIpAddress_SuccessWithWlan0(t *testing.T) {
    // 保存原函数，测试结束恢复
    originNetInterfaces := netInterfaces
    originGetAddrs := getInterfaceAddrs
    defer func() {
        netInterfaces = originNetInterfaces
        getInterfaceAddrs = originGetAddrs
    }()

    // mock网卡列表返回
    netInterfaces = func() ([]net.Interface, error) {
        return []net.Interface{
            {Name: InterfaceWlan},
            {Name: "dummy0"},
        }, nil
    }

    // mock指定网卡的地址返回
    getInterfaceAddrs = func(i net.Interface) ([]net.Addr, error) {
        if i.Name == InterfaceWlan {
            // 构造你需要的测试IP，比如192.168.3.15/24
            _, ipNet, _ := net.ParseCIDR("192.168.3.15/24")
            return []net.Addr{ipNet}, nil
        }
        return nil, nil
    }

    // 执行测试断言
    address, err := GetIpAddress()
    if err != nil {
        t.Errorf("GetIpAddress unexpected error: %v", err)
        return
    }
    expectIP := net.ParseIP("192.168.3.15")
    if !address.Equal(expectIP) {
        t.Errorf("GetIpAddress expected ip %v, got %v", expectIP, address)
    }
}

你也可以灵活mock异常场景，比如让netInterfaces返回错误、让getInterfaceAddrs返回错误，覆盖所有分支逻辑。

方案2：依赖注入（适合长期维护的中大型项目） #

如果项目后续会扩展更多网络操作，推荐用接口抽象依赖，完全解耦标准库实现，可直接用gomock生成mock对象。

步骤1：抽象网络操作接口 #

// NetworkInterface 抽象网卡操作
type NetworkInterface interface {
    GetName() string
    GetAddrs() ([]net.Addr, error)
}

// NetworkManager 抽象全局网络操作
type NetworkManager interface {
    GetInterfaces() ([]NetworkInterface, error)
}

步骤2：实现原生逻辑 #

// 原生实现，调用标准库能力
type StdNetworkInterface struct {
    iface net.Interface
}

func (s StdNetworkInterface) GetName() string {
    return s.iface.Name
}

func (s StdNetworkInterface) GetAddrs() ([]net.Addr, error) {
    return s.iface.Addrs()
}

type StdNetworkManager struct{}

func (s StdNetworkManager) GetInterfaces() ([]NetworkInterface, error) {
    ifaces, err := net.Interfaces()
    if err != nil {
        return nil, err
    }
    res := make([]NetworkInterface, len(ifaces))
    for idx, i := range ifaces {
        res[idx] = StdNetworkInterface{iface: i}
    }
    return res, nil
}

步骤3：调整业务逻辑为依赖注入模式 #

func GetIpAddress(manager NetworkManager) (net.IP, error) {
    ifaces, err := manager.GetInterfaces()
    if err != nil {
        return nil, err
    }
    for _, i := range ifaces {
        if i.GetName() == InterfaceWlan || i.GetName() == InterfaceEthernet {
            addrs, err := i.GetAddrs()
            // 原有处理逻辑不变
        }
    }
    return nil, errors.New("network: ip not found")
}

步骤4：测试实现 #

用gomock生成NetworkManager和NetworkInterface的mock实现，测试时直接传入mock对象，灵活控制所有返回值即可。

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