Go语言SSH客户端单元测试实现及并发场景适配问询

我完全懂你这种感受——从简单的加减测试跳到真实业务的SSH客户端测试，确实是个不小的坎。尤其是SSH这种依赖网络、外部设备的组件，再加上并发场景，测试起来确实有点无从下手。我来一步步给你拆解怎么搞：

首先你得明白：单元测试要测的是你的代码逻辑，而不是SSH协议本身或者第三方库的功能。所以第一步必须把SSH相关的依赖抽象成接口，这样测试时才能用Mock实现来替代真实的SSH连接。

比如，你的客户端肯定会用到ssh.Session的一些方法（比如Run、Output、Close），那你就定义一个自己的接口：

// SSHSession 抽象SSH会话的核心操作
type SSHSession interface {
    Run(cmd string) error
    Output(cmd string) ([]byte, error)
    Close() error
}

然后你的客户端结构体要依赖这个接口，而不是直接依赖ssh.Session：

type SSHClient struct {
    session SSHSession
    // 其他字段，比如设备地址、用户名等
}

// 比如你封装的执行命令方法
func (c *SSHClient) ExecuteCommand(cmd string) (string, error) {
    output, err := c.session.Output(cmd)
    if err != nil {
        return "", fmt.Errorf("failed to run command: %w", err)
    }
    defer c.session.Close()
    return string(output), nil
}

这样一来，你的客户端和真实的SSH服务就解耦了，测试时随便换Mock实现就行。

Mock的本质就是“伪造”一个符合接口的实现，让它按你预设的逻辑返回结果，这样就能模拟各种场景（成功、失败、超时等）。

你可以选择手动写Mock，或者用Go生态里的Mock框架（比如testify/mock，轻量好用）。这里先给你看手动Mock的例子，简单直观：

// MockSession 手动实现的Mock SSH会话
type MockSession struct {
    presetOutput []byte
    presetErr    error
    closeInvoked bool // 记录Close方法是否被调用
}

func (m *MockSession) Run(cmd string) error {
    return m.presetErr
}

func (m *MockSession) Output(cmd string) ([]byte, error) {
    return m.presetOutput, m.presetErr
}

func (m *MockSession) Close() error {
    m.closeInvoked = true
    return nil
}

这个MockSession可以根据你的测试需求，预设不同的返回值，比如模拟命令执行失败、返回特定输出等。

现在你可以针对SSHClient的方法写测试了，核心是覆盖各种业务场景，比如：

• 命令执行成功的情况
• 命令执行失败的情况
• 会话关闭是否被正确调用
• 错误信息是否被正确封装

用表驱动测试会让你的代码更简洁，覆盖更多场景：

import (
    "fmt"
    "testing"
    "github.com/stretchr/testify/assert"
)

func TestSSHClient_ExecuteCommand(t *testing.T) {
    // 定义测试用例表，每个用例对应一种场景
    testCases := []struct {
        name         string
        presetOutput []byte
        presetErr    error
        expectOut    string
        expectErr    bool
    }{
        {
            name:         "command executes successfully",
            presetOutput: []byte("device config updated"),
            presetErr:    nil,
            expectOut:    "device config updated",
            expectErr:    false,
        },
        {
            name:         "command execution fails",
            presetOutput: nil,
            presetErr:    fmt.Errorf("permission denied"),
            expectOut:    "",
            expectErr:    true,
        },
    }

    for _, tc := range testCases {
        t.Run(tc.name, func(t *testing.T) {
            // 初始化MockSession
            mockSession := &MockSession{
                presetOutput: tc.presetOutput,
                presetErr:    tc.presetErr,
            }
            // 创建你的SSH客户端，注入MockSession
            client := &SSHClient{session: mockSession}

            // 执行要测试的方法
            out, err := client.ExecuteCommand("configure terminal")

            // 断言结果是否符合预期
            if tc.expectErr {
                assert.Error(t, err)
                assert.Contains(t, err.Error(), "failed to run command") // 检查错误信息是否正确封装
            } else {
                assert.NoError(t, err)
                assert.Equal(t, tc.expectOut, out)
            }
            // 断言Close方法是否被调用（资源是否正确释放）
            assert.True(t, mockSession.closeInvoked)
        })
    }
}

运行go test就能执行这些测试，完全不需要真实的SSH服务器！

你的客户端要用于并发多设备配置，这部分测试需要关注两个点：竞态条件和并发逻辑正确性。

1. 检测竞态条件 #

Go内置了竞态检测器，只要运行测试时加上-race参数：

go test -race ./...

它会自动检测你的代码中是否有数据竞争（比如多个goroutine同时读写共享变量但没加锁）。如果你的SSHClient结构体中有共享状态（比如全局连接池），一定要用这个工具检测。

2. 测试并发执行逻辑 #

比如你有一个BatchConfigure方法，同时给多个设备发命令，你需要测试：

• 所有设备的命令都被执行
• 成功和失败的结果被正确收集
• 所有会话都被正确关闭

测试时可以创建多个MockSession，每个模拟不同的响应，然后用goroutine并发执行：

func TestSSHClient_BatchConfigure(t *testing.T) {
    t.Parallel() // 标记这个测试用例可以和其他测试并行执行

    // 创建5个MockSession，模拟3个成功，2个失败
    mockSessions := []*MockSession{
        {presetOutput: []byte("dev1 ok"), presetErr: nil},
        {presetOutput: []byte("dev2 ok"), presetErr: nil},
        {presetOutput: []byte("dev3 ok"), presetErr: nil},
        {presetOutput: nil, presetErr: fmt.Errorf("dev4 timeout")},
        {presetOutput: nil, presetErr: fmt.Errorf("dev5 auth failed")},
    }

    // 假设你的BatchConfigure方法接收多个客户端，并发执行
    results, errors := BatchConfigure(mockSessions, "set system hostname")

    // 断言结果数量
    assert.Len(t, results, 3)
    assert.Len(t, errors, 2)

    // 断言所有会话都被关闭
    for _, sess := range mockSessions {
        assert.True(t, sess.closeInvoked)
    }
}

如果你的并发逻辑用到了sync.WaitGroup或者通道，测试时也要确保这些同步机制正常工作。

• 测试错误路径：不要只测成功的情况，要覆盖各种错误场景（连接失败、命令不存在、超时、权限不足等），这才是单元测试的价值所在。
• 用TestMain做前置准备：如果有一些通用的Mock初始化或者环境设置，可以放在TestMain函数里，减少重复代码。
• 避免测试第三方库：你的测试只需要关注自己封装的逻辑，比如ssh.Dial这类第三方方法，交给Go的标准库测试就行，你只需要Mock它的返回结果。

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