How to unit test server sent event?

I want to read a response from a server sent event in a unit tests. I want to avoid time.Sleep at all cost.

Currently I read the response w http.ResponseRecorder as such:

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

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

	go func() {
		for len(f.w.Body.Bytes()) == 0 {
		}

		byteCh <- f.w.Body.Bytes()
	}()

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

I wait for an event to be written as such:

for len(f.w.Body.Bytes()) == 0 {
}

What are the alternative without a for or a time.Sleep ?

I suppose io.ReadAll is sufficient.

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
    }
}

How about wrap httptest.ResponseRecorder and overwrite the Write and WriteString method?

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()
}

I'm still learning go, but would something like this work?

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
	}
}

The signal channel and a mutex added to the fixture struct. So the writeResponse sets the response body and it signals ready by closing the signal channel. The readResponse function waits for the signal before reading the response body.

I think this would avoid both your for loop and need to sleep.