Golang中文件系统变更的单元测试实践

在Go中测试文件系统变更，推荐使用以下几种方法：

1. 使用临时目录进行真实文件系统测试

package main

import (
    "os"
    "path/filepath"
    "testing"
    "github.com/stretchr/testify/assert"
)

func TestGitAddAndCommit(t *testing.T) {
    // 创建临时目录
    tempDir, err := os.MkdirTemp("", "git-test-*")
    assert.NoError(t, err)
    defer os.RemoveAll(tempDir)

    // 初始化git仓库
    err = os.Chdir(tempDir)
    assert.NoError(t, err)
    
    // 执行git init
    // ... git初始化代码
    
    // 创建测试文件
    testFile := filepath.Join(tempDir, "test.txt")
    err = os.WriteFile(testFile, []byte("test content"), 0644)
    assert.NoError(t, err)
    
    // 执行封装的git命令
    err = gitAddAndCommit("test commit")
    assert.NoError(t, err)
    
    // 验证文件状态
    // 可以通过git status验证
}

2. 使用接口抽象文件系统操作

package main

import (
    "io/fs"
    "os"
)

// FileSystem 接口
type FileSystem interface {
    Stat(name string) (fs.FileInfo, error)
    Remove(name string) error
    WriteFile(name string, data []byte, perm fs.FileMode) error
    ReadFile(name string) ([]byte, error)
}

// RealFileSystem 真实文件系统实现
type RealFileSystem struct{}

func (r RealFileSystem) Stat(name string) (fs.FileInfo, error) {
    return os.Stat(name)
}

func (r RealFileSystem) Remove(name string) error {
    return os.Remove(name)
}

func (r RealFileSystem) WriteFile(name string, data []byte, perm fs.FileMode) error {
    return os.WriteFile(name, data, perm)
}

func (r RealFileSystem) ReadFile(name string) ([]byte, error) {
    return os.ReadFile(name)
}

// MockFileSystem 用于测试的模拟实现
type MockFileSystem struct {
    Files map[string][]byte
    RemovedFiles []string
}

func (m *MockFileSystem) Stat(name string) (fs.FileInfo, error) {
    // 模拟实现
    return nil, nil
}

func (m *MockFileSystem) Remove(name string) error {
    m.RemovedFiles = append(m.RemovedFiles, name)
    delete(m.Files, name)
    return nil
}

func (m *MockFileSystem) WriteFile(name string, data []byte, perm fs.FileMode) error {
    m.Files[name] = data
    return nil
}

func (m *MockFileSystem) ReadFile(name string) ([]byte, error) {
    return m.Files[name], nil
}

3. 使用testing/fstest包进行内存文件系统测试

package main

import (
    "testing"
    "testing/fstest"
    "io/fs"
)

func TestWithInMemoryFS(t *testing.T) {
    // 创建内存文件系统
    fsys := fstest.MapFS{
        "file1.txt": &fstest.MapFile{
            Data: []byte("content1"),
        },
        "dir/file2.txt": &fstest.MapFile{
            Data: []byte("content2"),
        },
    }
    
    // 测试文件读取
    data, err := fs.ReadFile(fsys, "file1.txt")
    if err != nil {
        t.Fatal(err)
    }
    
    // 验证内容
    if string(data) != "content1" {
        t.Errorf("expected content1, got %s", string(data))
    }
}

4. 模拟git命令执行

package main

import (
    "bytes"
    "os/exec"
    "testing"
)

// GitExecutor 接口
type GitExecutor interface {
    Run(args ...string) (string, error)
}

// RealGitExecutor 真实git执行器
type RealGitExecutor struct{}

func (g RealGitExecutor) Run(args ...string) (string, error) {
    cmd := exec.Command("git", args...)
    var out bytes.Buffer
    cmd.Stdout = &out
    err := cmd.Run()
    return out.String(), err
}

// MockGitExecutor 模拟git执行器
type MockGitExecutor struct {
    Commands []string
    Outputs  map[string]string
    Errors   map[string]error
}

func (m *MockGitExecutor) Run(args ...string) (string, error) {
    m.Commands = append(m.Commands, args[0])
    
    // 根据命令返回预设的输出或错误
    if output, ok := m.Outputs[args[0]]; ok {
        return output, nil
    }
    
    if err, ok := m.Errors[args[0]]; ok {
        return "", err
    }
    
    return "", nil
}

// 测试示例
func TestGitWrapper(t *testing.T) {
    mockGit := &MockGitExecutor{
        Commands: []string{},
        Outputs: map[string]string{
            "status": "M modified.txt\nA new.txt",
            "log": "commit abc123",
        },
    }
    
    // 注入模拟的git执行器
    wrapper := &GitWrapper{executor: mockGit}
    
    // 执行测试
    err := wrapper.AddAndCommit("test commit")
    if err != nil {
        t.Fatal(err)
    }
    
    // 验证执行的命令
    expectedCommands := []string{"add", "commit"}
    for i, cmd := range expectedCommands {
        if mockGit.Commands[i] != cmd {
            t.Errorf("expected command %s, got %s", cmd, mockGit.Commands[i])
        }
    }
}

5. 完整测试示例

package main

import (
    "os"
    "os/exec"
    "path/filepath"
    "testing"
)

func TestGitAddCommitIntegration(t *testing.T) {
    // 准备测试环境
    tempDir := t.TempDir() // Go 1.15+ 提供的测试临时目录
    
    // 保存当前目录
    originalDir, err := os.Getwd()
    if err != nil {
        t.Fatal(err)
    }
    defer os.Chdir(originalDir)
    
    // 切换到临时目录
    if err := os.Chdir(tempDir); err != nil {
        t.Fatal(err)
    }
    
    // 初始化git仓库
    if err := exec.Command("git", "init").Run(); err != nil {
        t.Fatal(err)
    }
    
    // 配置git用户
    exec.Command("git", "config", "user.email", "test@example.com").Run()
    exec.Command("git", "config", "user.name", "Test User").Run()
    
    // 创建测试文件
    testFile := filepath.Join(tempDir, "test.txt")
    if err := os.WriteFile(testFile, []byte("test content"), 0644); err != nil {
        t.Fatal(err)
    }
    
    // 执行封装的git操作
    git := NewGitWrapper()
    if err := git.AddAndCommit("test commit message"); err != nil {
        t.Fatalf("AddAndCommit failed: %v", err)
    }
    
    // 验证提交
    cmd := exec.Command("git", "log", "--oneline")
    output, err := cmd.Output()
    if err != nil {
        t.Fatal(err)
    }
    
    if len(output) == 0 {
        t.Error("expected commit log, got empty")
    }
    
    // 验证文件状态
    cmd = exec.Command("git", "status", "--porcelain")
    output, err = cmd.Output()
    if err != nil {
        t.Fatal(err)
    }
    
    if len(output) != 0 {
        t.Errorf("expected clean working tree, got: %s", output)
    }
}

这些方法可以根据具体需求组合使用。对于Git封装器的测试，建议结合临时目录的真实测试和接口模拟的方式，既能保证测试的真实性，又能提高测试速度。