Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package ws
import (
"bytes"
"context"
"log/slog"
"net/http"
"net/http/httptest"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/coder/websocket"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// newTestWSPair creates a connected client/server WebSocket pair using httptest.
func newTestWSPairInternal(t *testing.T) (serverConn *websocket.Conn, cleanup func()) {
t.Helper()
serverReady := make(chan *websocket.Conn, 1)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
conn, err := websocket.Accept(w, r, nil)
if err != nil {
return
}
serverReady <- conn
}))
url := "ws" + strings.TrimPrefix(server.URL, "http")
cc, _, err := websocket.Dial(t.Context(), url, nil)
require.NoError(t, err)
sc := <-serverReady
return sc, func() {
_ = cc.CloseNow()
// The hub and the forwarders own the server side and may already have
// closed it, so close errors here are expected.
_ = sc.CloseNow()
server.Close()
}
}
func TestNewHub(t *testing.T) {
h := NewHub(10)
require.NotNil(t, h)
assert.Equal(t, 0, h.Len())
}
func TestHub_RegisterAndClientCount(t *testing.T) {
h := NewHub(10)
ctx := t.Context()
go h.Run(ctx)
serverConn, cleanup := newTestWSPairInternal(t)
defer cleanup()
c := NewClient(serverConn, 16)
h.register <- c
// Wait for registration to process
require.Eventually(t, func() bool {
return h.Len() == 1
}, time.Second, 5*time.Millisecond)
}
func TestHub_UnregisterClient(t *testing.T) {
h := NewHub(10)
ctx := t.Context()
go h.Run(ctx)
serverConn, cleanup := newTestWSPairInternal(t)
defer cleanup()
c := NewClient(serverConn, 16)
h.register <- c
require.Eventually(t, func() bool {
return h.Len() == 1
}, time.Second, 5*time.Millisecond)
h.unregister <- c
require.Eventually(t, func() bool {
return h.Len() == 0
}, time.Second, 5*time.Millisecond)
}
func TestHub_Broadcast(t *testing.T) {
h := NewHub(10)
ctx := t.Context()
go h.Run(ctx)
serverConn, cleanup := newTestWSPairInternal(t)
defer cleanup()
c := NewClient(serverConn, 16)
h.register <- c
require.Eventually(t, func() bool {
return h.Len() == 1
}, time.Second, 5*time.Millisecond)
msg := []byte("hello world")
h.Broadcast(msg)
// Message should appear on the client's send channel
select {
case received := <-c.send:
assert.Equal(t, msg, received)
case <-time.After(time.Second):
require.FailNow(t, "timed out waiting for broadcast message")
}
}
func TestHub_BroadcastToMultipleClients(t *testing.T) {
h := NewHub(10)
ctx := t.Context()
go h.Run(ctx)
const numClients = 5
clients := make([]*Client, numClients)
cleanups := make([]func(), numClients)
for i := range numClients {
sc, cleanup := newTestWSPairInternal(t)
cleanups[i] = cleanup
clients[i] = NewClient(sc, 16)
h.register <- clients[i]
}
defer func() {
for _, fn := range cleanups {
fn()
}
}()
require.Eventually(t, func() bool {
return h.Len() == numClients
}, time.Second, 5*time.Millisecond)
msg := []byte("broadcast to all")
h.Broadcast(msg)
for i, c := range clients {
select {
case received := <-c.send:
assert.Equal(t, msg, received, "client %d did not receive expected message", i)
case <-time.After(time.Second):
require.FailNowf(t, "unexpected failure", "client %d timed out waiting for broadcast message", i)
}
}
}
func TestHub_BackpressureDropsSlowClient(t *testing.T) {
h := NewHub(10)
ctx := t.Context()
go h.Run(ctx)
// Create a client with a tiny send buffer so it fills up fast
serverConn, cleanup := newTestWSPairInternal(t)
defer cleanup()
c := NewClient(serverConn, 1)
h.register <- c
require.Eventually(t, func() bool {
return h.Len() == 1
}, time.Second, 5*time.Millisecond)
// Fill the client's send buffer
c.send <- []byte("fill")
// Now broadcast — the client's channel is full, so it should get dropped
h.Broadcast([]byte("overflow"))
require.Eventually(t, func() bool {
return h.Len() == 0
}, time.Second, 5*time.Millisecond)
}
func TestHub_OnEmptyCallback(t *testing.T) {
h := NewHub(10)
ctx := t.Context()
go h.Run(ctx)
var called atomic.Bool
h.SetOnEmpty(func() {
called.Store(true)
})
serverConn, cleanup := newTestWSPairInternal(t)
defer cleanup()
c := NewClient(serverConn, 16)
h.register <- c
require.Eventually(t, func() bool {
return h.Len() == 1
}, time.Second, 5*time.Millisecond)
h.unregister <- c
require.Eventually(t, called.Load, time.Second, 5*time.Millisecond, "onEmpty callback was not called")
}
func TestHub_OnFirstClientCallback(t *testing.T) {
h := NewHub(10)
ctx := t.Context()
go h.Run(ctx)
var callCount atomic.Int32
h.SetOnFirstClient(func() {
callCount.Add(1)
})
sc1, cleanup1 := newTestWSPairInternal(t)
defer cleanup1()
sc2, cleanup2 := newTestWSPairInternal(t)
defer cleanup2()
h.register <- NewClient(sc1, 16)
h.register <- NewClient(sc2, 16)
require.Eventually(t, func() bool {
return h.Len() == 2
}, time.Second, 5*time.Millisecond)
require.Eventually(t, func() bool {
return callCount.Load() == 1
}, time.Second, 5*time.Millisecond)
}
func TestHub_OnEmptyCalledOnlyOnce(t *testing.T) {
h := NewHub(10)
ctx := t.Context()
go h.Run(ctx)
var callCount atomic.Int32
h.SetOnEmpty(func() {
callCount.Add(1)
})
// Register two clients
sc1, cleanup1 := newTestWSPairInternal(t)
defer cleanup1()
sc2, cleanup2 := newTestWSPairInternal(t)
defer cleanup2()
c1 := NewClient(sc1, 16)
c2 := NewClient(sc2, 16)
h.register <- c1
h.register <- c2
require.Eventually(t, func() bool {
return h.Len() == 2
}, time.Second, 5*time.Millisecond)
// Unregister first — should NOT trigger onEmpty
h.unregister <- c1
require.Eventually(t, func() bool {
return h.Len() == 1
}, time.Second, 5*time.Millisecond)
time.Sleep(50 * time.Millisecond)
assert.Equal(t, int32(0), callCount.Load(), "onEmpty should not fire while clients remain")
// Unregister last — should trigger onEmpty exactly once
h.unregister <- c2
require.Eventually(t, func() bool {
return callCount.Load() == 1
}, time.Second, 5*time.Millisecond)
}
func TestHub_ContextCancellation(t *testing.T) {
h := NewHub(10)
ctx, cancel := context.WithCancel(t.Context())
done := make(chan struct{})
go func() {
h.Run(ctx)
close(done)
}()
serverConn, cleanup := newTestWSPairInternal(t)
defer cleanup()
c := NewClient(serverConn, 16)
h.register <- c
require.Eventually(t, func() bool {
return h.Len() == 1
}, time.Second, 5*time.Millisecond)
cancel()
select {
case <-done:
// Hub exited as expected
case <-time.After(2 * time.Second):
require.FailNow(t, "Hub.Run did not exit after context cancellation")
}
// After closeAll, clients map should be empty
assert.Equal(t, 0, h.Len())
}
func TestHub_BroadcastBufferFull(t *testing.T) {
// Hub with a buffer of 1
h := NewHub(1)
ctx := t.Context()
// Don't run the hub — the broadcast channel will fill up
h.broadcast <- []byte("fill")
// This should not block (drops the message)
h.Broadcast([]byte("should be dropped"))
// Verify no panic or deadlock occurred
go h.Run(ctx)
}
func TestHub_BroadcastOverloadAggregatesDropWarning(t *testing.T) {
var logBuffer bytes.Buffer
previousLogger := slog.Default()
slog.SetDefault(slog.New(slog.NewTextHandler(&logBuffer, &slog.HandlerOptions{Level: slog.LevelWarn})))
t.Cleanup(func() { slog.SetDefault(previousLogger) })
h := NewHub(1)
h.broadcast <- []byte("fill")
h.lastWarned.Store(time.Now().UnixNano())
const dropCount = 1000
var wg sync.WaitGroup
for range dropCount {
wg.Go(func() {
h.Broadcast([]byte("overload"))
})
}
wg.Wait()
assert.Equal(t, uint64(dropCount), h.dropped.Load())
assert.Empty(t, logBuffer.String())
h.lastWarned.Store(time.Now().Add(-broadcastDropWarningInterval).UnixNano())
h.Broadcast([]byte("trigger aggregate warning"))
logLines := strings.Split(strings.TrimSpace(logBuffer.String()), "\n")
require.Len(t, logLines, 1)
assert.Contains(t, logLines[0], "websocket hub broadcast buffer full; dropping messages")
assert.Contains(t, logLines[0], "droppedCount=1001")
assert.Zero(t, h.dropped.Load())
h.Broadcast([]byte("still overloaded"))
assert.Len(t, strings.Split(strings.TrimSpace(logBuffer.String()), "\n"), 1)
assert.Equal(t, uint64(1), h.dropped.Load())
}
func TestHub_ConcurrentOperations(t *testing.T) {
h := NewHub(100)
ctx := t.Context()
go h.Run(ctx)
const goroutines = 10
var wg sync.WaitGroup
// Create all pairs in the test goroutine (newTestWSPair uses t).
pairs := make([]struct {
sc *websocket.Conn
cleanup func()
}, goroutines)
for i := range goroutines {
pairs[i].sc, pairs[i].cleanup = newTestWSPairInternal(t)
t.Cleanup(pairs[i].cleanup)
}
for i := range goroutines {
wg.Add(1)
go func(idx int) {
defer wg.Done()
sc := pairs[idx].sc
c := NewClient(sc, 16)
h.register <- c
time.Sleep(10 * time.Millisecond)
h.Broadcast([]byte("concurrent message"))
time.Sleep(10 * time.Millisecond)
h.unregister <- c
}(i)
}
wg.Wait()
// All clients should be gone
require.Eventually(t, func() bool {
return h.Len() == 0
}, 2*time.Second, 10*time.Millisecond)
}
func TestHub_DoubleUnregister(t *testing.T) {
h := NewHub(10)
ctx := t.Context()
go h.Run(ctx)
serverConn, cleanup := newTestWSPairInternal(t)
defer cleanup()
c := NewClient(serverConn, 16)
h.register <- c
require.Eventually(t, func() bool {
return h.Len() == 1
}, time.Second, 5*time.Millisecond)
// Unregister twice — should not panic
h.unregister <- c
require.Eventually(t, func() bool {
return h.Len() == 0
}, time.Second, 5*time.Millisecond)
// Second unregister should be harmless
h.unregister <- c
time.Sleep(50 * time.Millisecond)
assert.Equal(t, 0, h.Len())
}