io.ReadAll就足够了。

func (f *fixture) readResponse(t *testing.T) []byte {
    t.Helper()

    byteCh := make(chan []byte)
    timeout := time.After(100 * time.Millisecond)

    go func() {
        body, err := io.ReadAll(f.w.Body)
        if err != nil {
            // error handler
        }

        byteCh <- body
    }()

    select {
    case b := <-byteCh:
        return b
    case <-timeout:
        t.Error("no response received")
        return nil
    }
}

如何 Package httptest.ResponseRecorder并覆盖Write和WriteString方法？

package m

import (
    "fmt"
    "net/http"
    "net/http/httptest"
    "sync"
    "testing"
    "time"
)

type ServerEventRecorder struct {
    httptest.ResponseRecorder
    C chan []byte
}

func NewRecorder() *ServerEventRecorder {
    return &ServerEventRecorder{
        ResponseRecorder: *httptest.NewRecorder(),
        C:                make(chan []byte, 2),
    }
}

func (rw *ServerEventRecorder) Write(buf []byte) (int, error) {
    rw.C <- buf
    return rw.ResponseRecorder.Write(buf)
}

func (rw *ServerEventRecorder) WriteString(str string) (int, error) {
    rw.C <- []byte(str)
    return rw.ResponseRecorder.WriteString(str)
}

func (rw *ServerEventRecorder) Close() {
    close(rw.C)
}

func TestXxx(t *testing.T) {
    handler := func(w http.ResponseWriter, r *http.Request) {
        for i := 0; i < 5; i++ {
            i := i
            time.Sleep(100 * time.Millisecond)
            fmt.Fprintf(w, "data: some text - %d", i)
        }
    }

    req := httptest.NewRequest("GET", "http://example.com/foo", nil)
    w := NewRecorder()

    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        for buf := range w.C {
            t.Logf("%s\n", buf)
        }
        wg.Done()
    }()

    handler(w, req)
    w.Close()
    wg.Wait()
}

我还在学围棋，但这样的东西有用吗？

type fixture struct {
    w      *httptest.ResponseRecorder
    signal chan struct{}
    mu     sync.Mutex
}

func newFixture() *fixture {
    return &fixture{
        w:      httptest.NewRecorder(),
        signal: make(chan struct{}),
    }
}

func (f *fixture) writeResponse(data []byte) {
    f.mu.Lock()
    f.w.Body = bytes.NewBuffer(data)
    f.mu.Unlock()

    // Signal that the response is ready
    close(f.signal)
}

func (f *fixture) readResponse(t *testing.T) []byte {
    t.Helper()

    timeout := time.After(100 * time.Millisecond)

    select {
    case <-f.signal:
        f.mu.Lock()
        b := f.w.Body.Bytes()
        f.mu.Unlock()
        return b
    case <-timeout:
        t.Error("no response received")
        return nil
    }
}

信号通道和互斥体被添加到fixture结构中。因此writeResponse设置响应体，并通过关闭信号通道发出就绪信号。readResponse函数在阅读响应体之前等待信号。
我认为这将避免你的for循环和需要睡眠。