Golang中如何测试/模糊测试类ncurses的文本用户界面

对于测试 tview 这类基于 ncurses 的文本用户界面，可以通过模拟终端输入和捕获输出来实现自动化。以下是一种使用 pty 和 goexpect 的解决方案，并提供了示例代码：

package main

import (
    "fmt"
    "io"
    "os"
    "testing"
    "time"

    "github.com/creack/pty"
    "github.com/google/goexpect"
    "github.com/rivo/tview"
)

// 启动 tview 应用并连接到 pty
func startTViewApp(ptyFile *os.File) error {
    app := tview.NewApplication()
    textView := tview.NewTextView().
        SetText("配置选项界面\n按 Tab 导航\n按 Enter 确认")
    app.SetRoot(textView, true)
    
    // 将应用输出重定向到 pty
    app.SetScreen(tview.NewTestScreen(ptyFile))
    
    // 在 goroutine 中运行应用
    go func() {
        if err := app.Run(); err != nil {
            fmt.Printf("应用错误: %v\n", err)
        }
    }()
    
    return nil
}

// 测试函数示例
func TestTViewNavigation(t *testing.T) {
    // 创建主从 pty
    master, slave, err := pty.Open()
    if err != nil {
        t.Fatalf("创建 pty 失败: %v", err)
    }
    defer master.Close()
    defer slave.Close()

    // 启动 tview 应用
    if err := startTViewApp(slave); err != nil {
        t.Fatalf("启动应用失败: %v", err)
    }

    // 创建 expect 实例
    expecter, _, err := goexpect.SpawnWithArgs(
        []string{"cat"},
        time.Second*5,
        goexpect.Tee(master),
        goexpect.Verbose(true),
    )
    if err != nil {
        t.Fatalf("创建 expect 失败: %v", err)
    }
    defer expecter.Close()

    // 发送 Tab 键进行导航
    _, err = expecter.ExpectBatch([]goexpect.Batcher{
        &goexpect.BExp{R: "配置选项界面"},
        &goexpect.BSnd{S: "\t"},
        &goexpect.BExp{R: ".*"}, // 匹配任意输出
    }, time.Second*2)
    
    if err != nil {
        t.Errorf("导航测试失败: %v", err)
    }

    // 发送 Enter 键
    _, err = expecter.Send("\n")
    if err != nil {
        t.Errorf("发送 Enter 失败: %v", err)
    }
}

// 模糊测试示例
func FuzzTViewInput(f *testing.F) {
    // 添加初始测试用例
    testCases := []string{
        "\t",    // Tab
        "\n",    // Enter
        "\x1b[A", // 上箭头
        "\x1b[B", // 下箭头
    }
    for _, tc := range testCases {
        f.Add(tc)
    }

    f.Fuzz(func(t *testing.T, input string) {
        master, slave, err := pty.Open()
        if err != nil {
            t.Skipf("创建 pty 失败: %v", err)
        }
        defer master.Close()
        defer slave.Close()

        // 启动应用
        app := tview.NewApplication()
        textView := tview.NewTextView()
        app.SetRoot(textView, true)
        app.SetScreen(tview.NewTestScreen(slave))

        done := make(chan error, 1)
        go func() {
            done <- app.Run()
        }()

        // 发送模糊输入
        _, err = master.Write([]byte(input))
        if err != nil {
            t.Logf("写入输入失败: %v", err)
        }

        // 等待并检查应用状态
        select {
        case err := <-done:
            if err != nil {
                t.Errorf("应用异常退出: %v", err)
            }
        case <-time.After(100 * time.Millisecond):
            // 应用仍在运行，正常停止
            app.Stop()
        }
    })
}

对于避免 exec 以加速模糊测试，可以使用进程内测试。以下示例展示了如何直接调用应用逻辑：

// 进程内模糊测试
func FuzzTViewInProcess(f *testing.F) {
    f.Fuzz(func(t *testing.T, input []byte) {
        // 创建虚拟终端
        master, slave, err := pty.Open()
        if err != nil {
            t.Skipf("创建 pty 失败: %v", err)
        }
        defer master.Close()
        defer slave.Close()

        // 直接调用应用逻辑
        app := tview.NewApplication()
        form := tview.NewForm()
        app.SetRoot(form, true)
        
        // 使用测试屏幕
        screen := tview.NewTestScreen(slave)
        app.SetScreen(screen)

        // 在 goroutine 中运行
        done := make(chan error, 1)
        go func() {
            done <- app.Run()
        }()

        // 发送模糊输入
        for _, b := range input {
            // 模拟按键事件
            event := tcell.NewEventKey(tcell.Key(b), rune(b), tcell.ModNone)
            screen.PostEvent(event)
        }

        // 清理
        select {
        case <-time.After(50 * time.Millisecond):
            app.Stop()
        case err := <-done:
            if err != nil {
                t.Errorf("应用错误: %v", err)
            }
        }
    })
}

对于覆盖率跟踪，确保在测试命令中启用覆盖率收集：

go test -fuzz=Fuzz -coverprofile=coverage.out ./...

这种方法避免了外部进程执行，保持了覆盖率跟踪的有效性，同时通过 pty 模拟了真实的终端交互环境。