如何对返回多文件流的HTTP Handler进行单元测试并处理数据？

一、核心问题说明 #

你当前的Handler直接用io.MultiReader把多个文件流拼接成单一二进制流返回，没有任何分隔标识或元数据，所以测试里拿到的是完全拼接后的字节数组，没法直接自动分离——除非提前知道每个文件的长度、内容特征，或者修改Handler的返回格式。

二、处理Handler返回的流数据 #

你现在的Send函数用ioutil.ReadAll把整个响应读进内存，小文件没问题，但如果文件很大会导致内存占用过高。可以按需求选择两种处理方式：

1. 保持全量读取（适合小文件场景） #

Go 1.16+已废弃ioutil.ReadAll，建议替换为标准库的io.ReadAll：

func Send(req *http.Request, handler Handler) ([]byte, error) {
    w := httptest.NewRecorder()
    e := echo.New()
    c := e.NewContext(req, w)
    if err := handler(c); err != nil {
        return nil, err
    }
    res := w.Result()
    defer res.Body.Close()
    return io.ReadAll(res.Body) // 替换废弃的ioutil.ReadAll
}

2. 流式处理（适合大文件场景） #

避免一次性加载全量数据，直接返回响应体的io.ReadCloser，在测试里逐块处理：

func SendStream(req *http.Request, handler Handler) (io.ReadCloser, error) {
    w := httptest.NewRecorder()
    e := echo.New()
    c := e.NewContext(req, w)
    if err := handler(c); err != nil {
        return nil, err
    }
    res := w.Result()
    return res.Body, nil
}

// 测试中使用流式处理
body, err := SendStream(req, RouteHandler)
if err != nil {
    t.Fatal(err)
}
defer body.Close()

buf := make([]byte, 1024)
for {
    n, err := body.Read(buf)
    if err == io.EOF {
        break
    }
    if err != nil {
        t.Fatal(err)
    }
    // 处理当前读取到的buf[:n]字节
}

三、分离返回的多个文件 #

分两种场景给出解决方案：

场景1：不修改现有Handler（仅测试用） #

如果测试时提前知道每个测试文件的长度，可以直接按长度拆分总字节数组：

func splitFiles(total []byte, fileSizes []int64) ([][]byte, error) {
    var files [][]byte
    offset := 0
    for _, size := range fileSizes {
        if int64(offset)+size > int64(len(total)) {
            return nil, fmt.Errorf("文件长度超出总字节数")
        }
        files = append(files, total[offset:offset+int(size)])
        offset += int(size)
    }
    return files, nil
}

// 测试调用示例
data, err := Send(req, RouteHandler)
if err != nil {
    t.Fatal(err)
}
// 假设测试用的5个文件长度分别为100、200、300、400、500字节
fileSizes := []int64{100, 200, 300, 400, 500}
files, err := splitFiles(data, fileSizes)
if err != nil {
    t.Fatal(err)
}
// files数组中就是分离后的单个文件字节数据

如果文件有唯一内容特征（比如开头固定魔法数），也可以遍历字节数组查找特征位置拆分，但这种方式稳定性差，仅适合特定场景。

场景2：修改Handler（长期可靠方案） #

给返回的流添加标准分隔逻辑，让测试和客户端都能明确区分文件，推荐两种标准方式：

方式a：返回multipart格式

将多个文件包装成multipart/form-data格式，用标准库解析：

func RouteHandler(c echo.Context) error {
    var buf bytes.Buffer
    writer := multipart.NewWriter(&buf)

    for i := 0; i < 5; i++ {
        // 替换为你的文件获取逻辑
        file := getFileReader(i)
        fileName := fmt.Sprintf("file%d.bin", i)
        
        part, err := writer.CreateFormFile("files", fileName)
        if err != nil {
            return err
        }
        if _, err = io.Copy(part, file); err != nil {
            return err
        }
    }
    writer.Close()

    // 设置包含boundary的Content-Type
    c.Response().Header().Set(echo.HeaderContentType, writer.FormDataContentType())
    return c.Stream(http.StatusOK, writer.FormDataContentType(), &buf)
}

测试时用multipart.Reader解析：

data, err := Send(req, RouteHandler)
if err != nil {
    t.Fatal(err)
}

// 从Content-Type中提取boundary
func boundaryFromContentType(ct string) string {
    _, params, err := mime.ParseMediaType(ct)
    if err != nil {
        return ""
    }
    return params["boundary"]
}

reader := multipart.NewReader(bytes.NewReader(data), boundaryFromContentType(res.Header.Get(echo.HeaderContentType)))
for {
    part, err := reader.NextPart()
    if err == io.EOF {
        break
    }
    if err != nil {
        t.Fatal(err)
    }
    defer part.Close()
    // 读取单个文件内容
    fileData, err := io.ReadAll(part)
    if err != nil {
        t.Fatal(err)
    }
    // 处理单个文件数据
}

方式b：自定义元数据头+分隔符

在响应头中记录每个文件的长度，同时用自定义分隔符分隔文件流：

func RouteHandler(c echo.Context) error {
    var fileSizes []int64
    var readers []io.Reader
    separator := []byte("---FILE_SEPARATOR---")

    for i := 0; i < 5; i++ {
        file := getFileReader(i)
        size := getFileSize(i) // 替换为你的文件长度获取逻辑
        fileSizes = append(fileSizes, size)
        readers = append(readers, file, bytes.NewReader(separator))
    }
    // 移除最后一个多余的分隔符
    readers = readers[:len(readers)-1]

    // 在响应头中记录文件长度，用逗号分隔
    sizeStr := strings.Join(strings.Fields(fmt.Sprint(fileSizes)), ",")
    c.Response().Header().Set("X-File-Sizes", sizeStr)
    return c.Stream(http.StatusOK, "application/binary", io.MultiReader(readers...))
}

测试时从响应头解析长度，结合分隔符拆分：

// 修改Send函数，返回响应头和body
func SendWithHeader(req *http.Request, handler Handler) (http.Header, []byte, error) {
    w := httptest.NewRecorder()
    e := echo.New()
    c := e.NewContext(req, w)
    if err := handler(c); err != nil {
        return nil, nil, err
    }
    res := w.Result()
    defer res.Body.Close()
    data, err := io.ReadAll(res.Body)
    return res.Header, data, err
}

// 测试调用示例
header, data, err := SendWithHeader(req, RouteHandler)
if err != nil {
    t.Fatal(err)
}

// 解析文件长度
sizeStr := header.Get("X-File-Sizes")
sizeStrs := strings.Split(sizeStr, ",")
var fileSizes []int64
for _, s := range sizeStrs {
    size, err := strconv.ParseInt(strings.TrimSpace(s), 10, 64)
    if err != nil {
        t.Fatal(err)
    }
    fileSizes = append(fileSizes, size)
}

// 根据文件长度和分隔符拆分数据（需结合Handler的流顺序调整逻辑）

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