Renamed package, set up for worker session pattern.

initiatorpool/worker_test.go

@@ -0,0 +1,185 @@
+package initiatorpool
+
+import (
+	"git.wisehodl.dev/jay/go-honeybee/honeybeetest"
+	// "git.wisehodl.dev/jay/go-honeybee/transport"
+	// "git.wisehodl.dev/jay/go-honeybee/types"
+	"github.com/stretchr/testify/assert"
+	// "net/http"
+	"testing"
+	"time"
+)
+
+// Forwarder
+
+func TestRunForwarder(t *testing.T) {
+	t.Run("message passes through to inbox", func(t *testing.T) {
+		messages := make(chan receivedMessage, 1)
+		inbox := make(chan InboxMessage, 1)
+		stop := make(chan struct{})
+		defer close(stop)
+
+		w := &Worker{id: "wss://test"}
+		go w.runForwarder(messages, inbox, stop, nil, 0)
+
+		messages <- receivedMessage{data: []byte("hello"), receivedAt: time.Now()}
+
+		assert.Eventually(t, func() bool {
+			select {
+			case msg := <-inbox:
+				return string(msg.Data) == "hello" && msg.ID == "wss://test"
+			default:
+				return false
+			}
+		}, honeybeetest.TestTimeout, honeybeetest.TestTick)
+	})
+
+	t.Run("oldest message dropped when queue is full", func(t *testing.T) {
+		messages := make(chan receivedMessage, 1)
+		inbox := make(chan InboxMessage, 1)
+		stop := make(chan struct{})
+		defer close(stop)
+
+		gate := make(chan struct{})
+		gatedInbox := make(chan InboxMessage)
+
+		// gate the inbox from receiving messages until the gate is opened
+		go func() {
+			<-gate
+			for msg := range gatedInbox {
+				inbox <- msg
+			}
+		}()
+
+		w := &Worker{id: "wss://test"}
+		go w.runForwarder(messages, gatedInbox, stop, nil, 2)
+
+		// send three messages while the gated inbox is blocked
+		messages <- receivedMessage{data: []byte("first"), receivedAt: time.Now()}
+		messages <- receivedMessage{data: []byte("second"), receivedAt: time.Now()}
+		messages <- receivedMessage{data: []byte("third"), receivedAt: time.Now()}
+
+		// allow time for the first message to be dropped
+		time.Sleep(20 * time.Millisecond)
+
+		// close the gate, draining messages into the inbox
+		close(gate)
+
+		// receive messages from the inbox
+		var received []string
+		assert.Eventually(t, func() bool {
+			select {
+			case msg := <-inbox:
+				received = append(received, string(msg.Data))
+			default:
+			}
+			return len(received) == 2
+		}, honeybeetest.TestTimeout, honeybeetest.TestTick)
+
+		// first message was dropped
+		assert.Equal(t, []string{"second", "third"}, received)
+
+	})
+
+	t.Run("exits on stop", func(t *testing.T) {
+		messages := make(chan receivedMessage, 1)
+		inbox := make(chan InboxMessage, 1)
+		stop := make(chan struct{})
+
+		w := &Worker{id: "wss://test"}
+		done := make(chan struct{})
+		go func() {
+			w.runForwarder(messages, inbox, stop, nil, 0)
+			close(done)
+		}()
+
+		close(stop)
+		assert.Eventually(t, func() bool {
+			select {
+			case <-done:
+				return true
+			default:
+				return false
+			}
+		}, honeybeetest.TestTimeout, honeybeetest.TestTick)
+	})
+}
+
+func TestRunIdleMonitor(t *testing.T) {
+	t.Run("heartbeat resets timer, no idle signal fired", func(t *testing.T) {
+		heartbeat := make(chan struct{}, 3)
+		idle := make(chan struct{}, 1)
+		stop := make(chan struct{})
+		defer close(stop)
+
+		w := &Worker{config: &WorkerConfig{IdleTimeout: 100 * time.Millisecond}}
+		go w.runIdleMonitor(heartbeat, idle, stop, nil)
+
+		// send heartbeats faster than the timeout
+		for i := 0; i < 5; i++ {
+			time.Sleep(30 * time.Millisecond)
+			heartbeat <- struct{}{}
+		}
+
+		// because the timer is being reset, idle signal should not be sent
+		assert.Never(t, func() bool {
+			select {
+			case <-idle:
+				return true
+			default:
+				return false
+			}
+		}, honeybeetest.NegativeTestTimeout, honeybeetest.TestTick)
+	})
+
+	t.Run("idle timeout fires signal", func(t *testing.T) {
+		heartbeat := make(chan struct{})
+		idle := make(chan struct{}, 1)
+		stop := make(chan struct{})
+		defer close(stop)
+
+		w := &Worker{config: &WorkerConfig{IdleTimeout: 20 * time.Millisecond}}
+		go w.runIdleMonitor(heartbeat, idle, stop, nil)
+
+		// send no heartbeats, wait for timeout and idle signal
+		assert.Eventually(t, func() bool {
+			select {
+			case <-idle:
+				return true
+			default:
+				return false
+			}
+		}, honeybeetest.TestTimeout, honeybeetest.TestTick)
+	})
+
+	t.Run("exits on stop", func(t *testing.T) {
+		heartbeat := make(chan struct{})
+		idle := make(chan struct{}, 1)
+		stop := make(chan struct{})
+
+		w := &Worker{config: &WorkerConfig{IdleTimeout: 20 * time.Second}}
+		done := make(chan struct{})
+		go func() {
+			w.runIdleMonitor(heartbeat, idle, stop, nil)
+			close(done)
+		}()
+
+		// send stop signal
+		close(stop)
+		assert.Eventually(t, func() bool {
+			select {
+			case <-done:
+				return true
+			default:
+				return false
+			}
+		}, honeybeetest.TestTimeout, honeybeetest.TestTick)
+	})
+
+}
+
+func TestRunReconnector(t *testing.T) {
+	t.Run("reconnect emits events, new connection", func(t *testing.T) {})
+	t.Run("dial failure emits error", func(t *testing.T) {})
+	t.Run("exits on stop", func(t *testing.T) {})
+}