Golang中如何对依赖io.File.Write()的函数进行单元测试

在Go中测试依赖io.File.Write()的函数，可以通过接口抽象和依赖注入来实现。以下是两种实用的测试方案：

方案一：使用接口抽象（推荐）

首先定义文件操作接口，使函数不直接依赖具体实现：

// 定义文件操作接口
type FileSystem interface {
    Open(name string) (File, error)
    Create(name string) (File, error)
}

type File interface {
    Read(p []byte) (n int, err error)
    Write(p []byte) (n int, err error)
    Close() error
}

// 实际的文件系统实现
type OSFileSystem struct{}

func (fs *OSFileSystem) Open(name string) (File, error) {
    return os.Open(name)
}

func (fs *OSFileSystem) Create(name string) (File, error) {
    return os.Create(name)
}

// 修改你的函数，接受文件系统接口
func FileCopy(fs FileSystem, pathfrom, pathto string, limit, offset int64) error {
    source, err := fs.Open(pathfrom)
    if err != nil {
        return err
    }
    defer source.Close()
    
    destination, err := fs.Create(pathto)
    if err != nil {
        return err
    }
    defer destination.Close()
    
    buf := make([]byte, 1024) // 示例缓冲区大小
    for {
        n, err := source.Read(buf)
        if err != nil && err != io.EOF {
            return err
        }
        if n > 0 {
            if _, err := destination.Write(buf[:n]); err != nil {
                return err
            }
        }
        if err == io.EOF {
            break
        }
    }
    return nil
}

方案二：使用内存文件系统进行测试

创建模拟的文件系统实现：

// 模拟文件系统用于测试
type MockFileSystem struct {
    files map[string][]byte
    openErrors map[string]error
    writeErrors map[string]error
}

func NewMockFileSystem() *MockFileSystem {
    return &MockFileSystem{
        files: make(map[string][]byte),
        openErrors: make(map[string]error),
        writeErrors: make(map[string]error),
    }
}

func (m *MockFileSystem) Open(name string) (File, error) {
    if err, ok := m.openErrors[name]; ok {
        return nil, err
    }
    data, ok := m.files[name]
    if !ok {
        return nil, os.ErrNotExist
    }
    return &mockFile{
        name: name,
        data: data,
        pos: 0,
        fs: m,
    }, nil
}

func (m *MockFileSystem) Create(name string) (File, error) {
    m.files[name] = []byte{}
    return &mockFile{
        name: name,
        data: []byte{},
        pos: 0,
        fs: m,
    }, nil
}

type mockFile struct {
    name string
    data []byte
    pos  int
    fs   *MockFileSystem
}

func (m *mockFile) Read(p []byte) (n int, err error) {
    if m.pos >= len(m.data) {
        return 0, io.EOF
    }
    n = copy(p, m.data[m.pos:])
    m.pos += n
    return n, nil
}

func (m *mockFile) Write(p []byte) (n int, err error) {
    if err, ok := m.fs.writeErrors[m.name]; ok {
        return 0, err
    }
    m.data = append(m.data[:m.pos], p...)
    m.pos += len(p)
    m.fs.files[m.name] = m.data
    return len(p), nil
}

func (m *mockFile) Close() error {
    return nil
}

单元测试示例

func TestFileCopy(t *testing.T) {
    tests := []struct {
        name        string
        sourceData  []byte
        wantErr     bool
        setupMock   func(*MockFileSystem)
    }{
        {
            name:       "successful copy",
            sourceData: []byte("test data"),
            setupMock:  func(mfs *MockFileSystem) {},
        },
        {
            name:       "empty file",
            sourceData: []byte{},
            setupMock:  func(mfs *MockFileSystem) {},
        },
        {
            name:       "source file not found",
            sourceData: nil,
            wantErr:    true,
            setupMock: func(mfs *MockFileSystem) {
                mfs.openErrors["source.txt"] = os.ErrNotExist
            },
        },
        {
            name:       "write error",
            sourceData: []byte("test"),
            wantErr:    true,
            setupMock: func(mfs *MockFileSystem) {
                mfs.writeErrors["dest.txt"] = errors.New("disk full")
            },
        },
    }
    
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            mfs := NewMockFileSystem()
            if tt.sourceData != nil {
                mfs.files["source.txt"] = tt.sourceData
            }
            tt.setupMock(mfs)
            
            err := FileCopy(mfs, "source.txt", "dest.txt", 0, 0)
            
            if tt.wantErr {
                if err == nil {
                    t.Errorf("expected error, got nil")
                }
                return
            }
            
            if err != nil {
                t.Errorf("unexpected error: %v", err)
                return
            }
            
            // 验证复制结果
            sourceData, _ := mfs.files["source.txt"]
            destData, ok := mfs.files["dest.txt"]
            if !ok {
                t.Errorf("destination file not created")
                return
            }
            
            if !bytes.Equal(sourceData, destData) {
                t.Errorf("data mismatch: source %v, dest %v", sourceData, destData)
            }
        })
    }
}

方案三：使用标准库的testing/fstest包

Go 1.16+ 提供了内存文件系统测试工具：

import "testing/fstest"

func TestFileCopyWithFSTest(t *testing.T) {
    testFS := fstest.MapFS{
        "source.txt": &fstest.MapFile{
            Data: []byte("hello world"),
        },
    }
    
    // 创建自定义的文件系统适配器
    type TestFSAdapter struct {
        fstest.MapFS
    }
    
    // 实现FileSystem接口的方法
    // ... 适配器实现代码
    
    // 使用适配器进行测试
}

这些方法避免了直接操作真实文件系统，使测试更加可控和快速。接口抽象的方法尤其推荐，因为它提高了代码的可测试性和灵活性。