怎样用Golang测试命令行工具 使用os/exec捕获输出与错误

// mycli/main.go
package main

import (
    "fmt"
    "os"
    "strings"
)

func main() {
    if len(os.Args) < 2 {
        fmt.Fprintln(os.Stderr, "错误：请提供一个名字。")
        os.Exit(1)
    }
    name := strings.Join(os.Args[1:], " ")
    if name == "bug" {
        fmt.Fprintln(os.Stderr, "这是一个bug，程序将崩溃。")
        os.Exit(2)
    }
    fmt.Printf("你好，%s！\n", name)
    os.Exit(0)
}

// mycli/main_test.go
package main_test

import (
    "bytes"
    "io/ioutil"
    "os"
    "os/exec"
    "path/filepath"
    "strings"
    "testing"
)

// setupTestBinary 编译我们的CLI工具到一个临时目录，并返回其路径
func setupTestBinary(t *testing.T) string {
    tmpDir, err := ioutil.TempDir("", "cli_test_")
    if err != nil {
        t.Fatalf("无法创建临时目录: %v", err)
    }
    t.Cleanup(func() {
        os.RemoveAll(tmpDir) // 测试结束后清理临时目录
    })

    binaryPath := filepath.Join(tmpDir, "mycli")
    if runtime.GOOS == "windows" {
        binaryPath += ".exe"
    }

    cmd := exec.Command("go", "build", "-o", binaryPath, "./")
    cmd.Dir = "../mycli" // 确保在正确的模块目录下编译
    if err := cmd.Run(); err != nil {
        t.Fatalf("无法编译CLI工具: %v", err)
    }
    return binaryPath
}

func TestMyCLI_Greeting(t *testing.T) {
    binaryPath := setupTestBinary(t)

    // 准备捕获标准输出和标准错误
    var stdout, stderr bytes.Buffer
    cmd := exec.Command(binaryPath, "世界")
    cmd.Stdout = &stdout
    cmd.Stderr = &stderr

    err := cmd.Run() // 执行命令
    if err != nil {
        t.Fatalf("执行命令失败: %v, stderr: %s", err, stderr.String())
    }

    // 断言标准输出
    expectedStdout := "你好，世界！\n"
    if stdout.String() != expectedStdout {
        t.Errorf("预期输出 '%s'，实际得到 '%s'", expectedStdout, stdout.String())
    }

    // 断言标准错误为空
    if stderr.Len() > 0 {
        t.Errorf("预期标准错误为空，实际得到 '%s'", stderr.String())
    }
}

func TestMyCLI_MissingArgument(t *testing.T) {
    binaryPath := setupTestBinary(t)

    var stdout, stderr bytes.Buffer
    cmd := exec.Command(binaryPath) // 不提供参数
    cmd.Stdout = &stdout
    cmd.Stderr = &stderr

    err := cmd.Run() // 执行命令，预期会失败
    if err == nil {
        t.Fatal("预期命令执行失败，但却成功了")
    }

    // 检查错误类型是否为 ExitError，并获取退出码
    exitErr, ok := err.(*exec.ExitError)
    if !ok {
        t.Fatalf("预期 ExitError，实际得到 %T", err)
    }
    if exitErr.ExitCode() != 1 {
        t.Errorf("预期退出码为 1，实际为 %d", exitErr.ExitCode())
    }

    expectedStderr := "错误：请提供一个名字。\n"
    if stderr.String() != expectedStderr {
        t.Errorf("预期错误输出 '%s'，实际得到 '%s'", expectedStderr, stderr.String())
    }

    if stdout.Len() > 0 {
        t.Errorf("预期标准输出为空，实际得到 '%s'", stdout.String())
    }
}

func TestMyCLI_BugScenario(t *testing.T) {
    binaryPath := setupTestBinary(t)

    var stdout, stderr bytes.Buffer
    cmd := exec.Command(binaryPath, "bug")
    cmd.Stdout = &stdout
    cmd.Stderr = &stderr

    err := cmd.Run()
    if err == nil {
        t.Fatal("预期命令执行失败，但却成功了")
    }

    exitErr, ok := err.(*exec.ExitError)
    if !ok {
        t.Fatalf("预期 ExitError，实际得到 %T", err)
    }
    if exitErr.ExitCode() != 2 {
        t.Errorf("预期退出码为 2，实际为 %d", exitErr.ExitCode())
    }

    expectedStderr := "这是一个bug，程序将崩溃。\n"
    if stderr.String() != expectedStderr {
        t.Errorf("预期错误输出 '%s'，实际得到 '%s'", expectedStderr, stderr.String())
    }
}

// 假设 cmd 已经设置好并执行了 cmd.Run()
err := cmd.Run()
if err != nil {
    // 检查是否是 ExitError
    var exitErr *exec.ExitError
    if errors.As(err, &exitErr) {
        // 根据退出码进行不同的断言
        if exitErr.ExitCode() == 1 {
            // 这是预期的参数缺失错误
            // t.Logf("命令以退出码 1 结束，符合预期。")
        } else if exitErr.ExitCode() == 2 {
            // 这是预期的内部错误
            // t.Logf("命令以退出码 2 结束，符合预期。")
        } else {
            // 其他非零退出码，可能不是我们预期的错误
            t.Errorf("命令以非预期退出码 %d 结束，错误: %v", exitErr.ExitCode(), err)
        }
    } else {
        // 这是一个非 ExitError 类型的错误，可能是执行命令本身的问题（如命令找不到）
        t.Fatalf("命令执行发生非 ExitError 错误: %v", err)
    }
} else {
    // 命令成功执行（退出码为 0）
    // t.Logf("命令成功执行，退出码为 0。")
}

// 这是一个辅助函数，用于编译CLI工具
func buildCLI(t *testing.T, sourcePath string) string {
    // 创建一个临时目录来存放编译后的二进制文件
    tmpDir, err := os.MkdirTemp("", "cli_bin_")
    if err != nil {
        t.Fatalf("无法创建临时目录: %v", err)
    }
    // 使用 t.Cleanup 确保测试结束后清理掉临时目录
    t.Cleanup(func() {
        os.RemoveAll(tmpDir)
    })

    // 确定二进制文件的完整路径和名称
    binaryName := "mycli"
    if runtime.GOOS == "windows" {
        binaryName += ".exe"
    }
    binaryPath := filepath.Join(tmpDir, binaryName)

    // 构建 go build 命令
    // sourcePath 应该是你的CLI工具的Go模块路径，例如 "./" 或 "../mycli"
    cmd := exec.Command("go", "build", "-o", binaryPath, sourcePath)
    // 设置命令的执行目录，确保它能在正确的上下文找到源文件
    // 如果你的测试文件和CLI工具在同一个模块下，且CLI工具在子目录，这里需要指定
    cmd.Dir = filepath.Dir(sourcePath) // 或者直接指定到模块根目录

    // 捕获编译过程中的输出，以便调试
    var buildStderr bytes.Buffer
    cmd.Stderr = &buildStderr

    // 执行编译命令
    if err := cmd.Run(); err != nil {
        t.Fatalf("编译CLI工具失败: %v\n编译输出:\n%s", err, buildStderr.String())
    }

    return binaryPath
}

// 在你的测试函数中调用它
func TestMyCLI_Example(t *testing.T) {
    // 假设你的CLI工具的main.go在与当前测试文件同级的 "mycli" 目录下
    cliBinaryPath := buildCLI(t, "../mycli")

    // 现在你可以使用 cliBinaryPath 来执行你的CLI工具了
    // cmd := exec.Command(cliBinaryPath, "arg1", "arg2")
    // ...
}