split up worker tests

2026-04-19 10:45:10 -04:00
parent 0715bde29d
commit e0fb919e83
7 changed files with 1156 additions and 1108 deletions
@@ -0,0 +1,391 @@
+package initiatorpool
+
+import (
+	"context"
+	"fmt"
+	"git.wisehodl.dev/jay/go-honeybee/honeybeetest"
+	"git.wisehodl.dev/jay/go-honeybee/transport"
+	"testing"
+)
+
+func drainEvent(t *testing.T, events <-chan PoolEvent, kind PoolEventKind) {
+	t.Helper()
+	honeybeetest.Eventually(t, func() bool {
+		select {
+		case e := <-events:
+			return e.Kind == kind
+		default:
+			return false
+		}
+	}, fmt.Sprintf("expected %s event", kind))
+}
+
+func TestRunSessionDial(t *testing.T) {
+	setup := func(t *testing.T) (
+		w *Worker,
+		ctx context.Context,
+		cancel context.CancelFunc,
+		dial chan struct{},
+		keepalive chan struct{},
+		newConn chan *transport.Connection,
+	) {
+		t.Helper()
+		ctx, cancel = context.WithCancel(context.Background())
+		w = &Worker{
+			ctx:       ctx,
+			cancel:    cancel,
+			id:        "wss://test",
+			config:    GetDefaultWorkerConfig(),
+			heartbeat: make(chan struct{}),
+		}
+		dial = make(chan struct{}, 1)
+		keepalive = make(chan struct{}, 1)
+		newConn = make(chan *transport.Connection, 1)
+		return
+	}
+
+	expectDial := func(t *testing.T, dial <-chan struct{}) {
+		t.Helper()
+		honeybeetest.Eventually(t, func() bool {
+			select {
+			case <-dial:
+				return true
+			default:
+				return false
+			}
+		}, "expected dial signal")
+	}
+
+	t.Run("fires dial immediately on entry", func(t *testing.T) {
+		w, ctx, cancel, dial, keepalive, newConn := setup(t)
+		defer cancel()
+
+		messages := make(chan receivedMessage, 1)
+		wctx := WorkerContext{Events: make(chan PoolEvent, 10)}
+
+		go w.runSession(ctx, wctx, messages, dial, keepalive, newConn)
+
+		expectDial(t, dial)
+	})
+
+	t.Run("keepalive fires dial", func(t *testing.T) {
+		w, ctx, cancel, dial, keepalive, newConn := setup(t)
+		defer cancel()
+
+		messages := make(chan receivedMessage, 1)
+		wctx := WorkerContext{Events: make(chan PoolEvent, 10)}
+
+		go w.runSession(ctx, wctx, messages, dial, keepalive, newConn)
+
+		// drain initial dial
+		expectDial(t, dial)
+
+		keepalive <- struct{}{}
+		expectDial(t, dial)
+	})
+
+	t.Run("multiple keepalive signals each fire dial", func(t *testing.T) {
+		w, ctx, cancel, dial, keepalive, newConn := setup(t)
+		defer cancel()
+
+		messages := make(chan receivedMessage, 1)
+		wctx := WorkerContext{Events: make(chan PoolEvent, 10)}
+
+		go w.runSession(ctx, wctx, messages, dial, keepalive, newConn)
+
+		// drain initial dial
+		expectDial(t, dial)
+
+		for i := 0; i < 3; i++ {
+			keepalive <- struct{}{}
+			expectDial(t, dial)
+		}
+	})
+}
+
+func TestRunSessionConnect(t *testing.T) {
+	setup := func(t *testing.T) (
+		w *Worker,
+		ctx context.Context,
+		cancel context.CancelFunc,
+		dial chan struct{},
+		keepalive chan struct{},
+		newConn chan *transport.Connection,
+		messages chan receivedMessage,
+	) {
+		t.Helper()
+		ctx, cancel = context.WithCancel(context.Background())
+		w = &Worker{
+			ctx:       ctx,
+			cancel:    cancel,
+			id:        "wss://test",
+			config:    GetDefaultWorkerConfig(),
+			heartbeat: make(chan struct{}),
+		}
+		dial = make(chan struct{}, 1)
+		keepalive = make(chan struct{}, 1)
+		newConn = make(chan *transport.Connection, 1)
+		messages = make(chan receivedMessage, 256)
+		return
+	}
+
+	t.Run("w.conn set after newConn received", func(t *testing.T) {
+		w, ctx, cancel, dial, keepalive, newConn, messages := setup(t)
+		wctx := WorkerContext{Events: make(chan PoolEvent, 10)}
+		defer cancel()
+
+		conn, _, _, _ := setupWorkerTestConnection(t)
+		go w.runSession(ctx, wctx, messages, dial, keepalive, newConn)
+
+		newConn <- conn
+
+		honeybeetest.Eventually(t, func() bool {
+			return w.conn.Load() != nil
+		}, "expected w.conn to be set")
+	})
+
+	t.Run("EventConnected emitted", func(t *testing.T) {
+		w, ctx, cancel, dial, keepalive, newConn, messages := setup(t)
+		events := make(chan PoolEvent, 10)
+		wctx := WorkerContext{Events: events}
+		defer cancel()
+
+		conn, _, _, _ := setupWorkerTestConnection(t)
+		go w.runSession(ctx, wctx, messages, dial, keepalive, newConn)
+
+		newConn <- conn
+
+		honeybeetest.Eventually(t, func() bool {
+			select {
+			case event := <-events:
+				return event.ID == w.id && event.Kind == EventConnected
+			default:
+				return false
+			}
+		}, "expected EventConnected")
+	})
+}
+
+func TestRunSessionDisconnect(t *testing.T) {
+	setup := func(t *testing.T) (
+		w *Worker,
+		ctx context.Context,
+		cancel context.CancelFunc,
+		dial chan struct{},
+		keepalive chan struct{},
+		newConn chan *transport.Connection,
+		messages chan receivedMessage,
+		conn *transport.Connection,
+		incomingData chan honeybeetest.MockIncomingData,
+	) {
+		t.Helper()
+		ctx, cancel = context.WithCancel(context.Background())
+		w = &Worker{
+			ctx:       ctx,
+			cancel:    cancel,
+			id:        "wss://test",
+			config:    GetDefaultWorkerConfig(),
+			heartbeat: make(chan struct{}),
+		}
+		dial = make(chan struct{}, 1)
+		keepalive = make(chan struct{}, 1)
+		newConn = make(chan *transport.Connection, 1)
+		messages = make(chan receivedMessage, 256)
+		conn, _, incomingData, _ = setupWorkerTestConnection(t)
+		return
+	}
+
+	t.Run("EventDisconnected emitted on connection close", func(t *testing.T) {
+		w, ctx, cancel, dial, keepalive, newConn, messages, conn, incomingData := setup(t)
+		events := make(chan PoolEvent, 10)
+		wctx := WorkerContext{Events: events}
+		defer cancel()
+
+		go w.runSession(ctx, wctx, messages, dial, keepalive, newConn)
+		newConn <- conn
+		drainEvent(t, events, EventConnected)
+
+		close(incomingData)
+
+		drainEvent(t, events, EventDisconnected)
+	})
+
+	t.Run("w.conn cleared after disconnect", func(t *testing.T) {
+		w, ctx, cancel, dial, keepalive, newConn, messages, conn, incomingData := setup(t)
+		events := make(chan PoolEvent, 10)
+		wctx := WorkerContext{Events: events}
+		defer cancel()
+
+		go w.runSession(ctx, wctx, messages, dial, keepalive, newConn)
+		newConn <- conn
+		drainEvent(t, events, EventConnected)
+
+		close(incomingData)
+		drainEvent(t, events, EventDisconnected)
+
+		honeybeetest.Eventually(t, func() bool {
+			return w.conn.Load() == nil
+		}, "expected w.conn to be cleared")
+	})
+
+	t.Run("dial fires again after disconnect", func(t *testing.T) {
+		w, ctx, cancel, dial, keepalive, newConn, messages, conn, incomingData := setup(t)
+		events := make(chan PoolEvent, 10)
+		wctx := WorkerContext{Events: events}
+		defer cancel()
+
+		go w.runSession(ctx, wctx, messages, dial, keepalive, newConn)
+		newConn <- conn
+		drainEvent(t, events, EventConnected)
+
+		// drain the initial dial signal before disconnecting
+		<-dial
+
+		close(incomingData)
+		drainEvent(t, events, EventDisconnected)
+
+		honeybeetest.Eventually(t, func() bool {
+			select {
+			case <-dial:
+				return true
+			default:
+				return false
+			}
+		}, "expected dial signal after disconnect")
+	})
+
+	t.Run("second connection cycle emits EventConnected", func(t *testing.T) {
+		w, ctx, cancel, dial, keepalive, newConn, messages, conn, incomingData := setup(t)
+		events := make(chan PoolEvent, 10)
+		wctx := WorkerContext{Events: events}
+		defer cancel()
+
+		go w.runSession(ctx, wctx, messages, dial, keepalive, newConn)
+		newConn <- conn
+		drainEvent(t, events, EventConnected)
+
+		close(incomingData)
+		drainEvent(t, events, EventDisconnected)
+
+		conn2, _, _, _ := setupWorkerTestConnection(t)
+		newConn <- conn2
+
+		drainEvent(t, events, EventConnected)
+	})
+}
+
+func TestRunSessionCancellation(t *testing.T) {
+	setup := func(t *testing.T) (
+		w *Worker,
+		ctx context.Context,
+		cancel context.CancelFunc,
+		dial chan struct{},
+		keepalive chan struct{},
+		newConn chan *transport.Connection,
+		messages chan receivedMessage,
+	) {
+		t.Helper()
+		ctx, cancel = context.WithCancel(context.Background())
+		w = &Worker{
+			ctx:       ctx,
+			cancel:    cancel,
+			id:        "wss://test",
+			config:    GetDefaultWorkerConfig(),
+			heartbeat: make(chan struct{}),
+		}
+		dial = make(chan struct{}, 1)
+		keepalive = make(chan struct{}, 1)
+		newConn = make(chan *transport.Connection, 1)
+		messages = make(chan receivedMessage, 256)
+		return
+	}
+
+	t.Run("ctx cancelled pre-connection exits without emitting events", func(t *testing.T) {
+		w, ctx, cancel, dial, keepalive, newConn, messages := setup(t)
+		events := make(chan PoolEvent, 10)
+		wctx := WorkerContext{Events: events}
+
+		done := make(chan struct{})
+		go func() {
+			defer close(done)
+			w.runSession(ctx, wctx, messages, dial, keepalive, newConn)
+		}()
+
+		cancel()
+
+		honeybeetest.Eventually(t, func() bool {
+			select {
+			case <-done:
+				return true
+			default:
+				return false
+			}
+		}, "expected runSession to exit")
+
+		honeybeetest.Never(t, func() bool {
+			select {
+			case <-events:
+				return true
+			default:
+				return false
+			}
+		}, "expected no events emitted")
+	})
+
+	t.Run("ctx cancelled post-connection emits EventDisconnected", func(t *testing.T) {
+		w, ctx, cancel, dial, keepalive, newConn, messages := setup(t)
+		events := make(chan PoolEvent, 10)
+		wctx := WorkerContext{Events: events}
+
+		conn, _, _, _ := setupWorkerTestConnection(t)
+
+		done := make(chan struct{})
+		go func() {
+			defer close(done)
+			w.runSession(ctx, wctx, messages, dial, keepalive, newConn)
+		}()
+
+		newConn <- conn
+
+		drainEvent(t, events, EventConnected)
+
+		cancel()
+
+		drainEvent(t, events, EventDisconnected)
+
+		honeybeetest.Eventually(t, func() bool {
+			select {
+			case <-done:
+				return true
+			default:
+				return false
+			}
+		}, "expected runSession to exit")
+	})
+
+	t.Run("ctx cancelled post-connection clears w.conn", func(t *testing.T) {
+		w, ctx, cancel, dial, keepalive, newConn, messages := setup(t)
+		events := make(chan PoolEvent, 10)
+		wctx := WorkerContext{Events: events}
+
+		conn, _, _, _ := setupWorkerTestConnection(t)
+
+		done := make(chan struct{})
+		go func() {
+			defer close(done)
+			w.runSession(ctx, wctx, messages, dial, keepalive, newConn)
+		}()
+
+		newConn <- conn
+
+		drainEvent(t, events, EventConnected)
+
+		cancel()
+
+		drainEvent(t, events, EventDisconnected)
+
+		honeybeetest.Eventually(t, func() bool {
+			return w.conn.Load() == nil
+		}, "expected w.conn to clear")
+	})
+}