diff --git a/honeybeetest/helpers.go b/honeybeetest/helpers.go
index 994aa1c..5ad036d 100644
--- a/honeybeetest/helpers.go
+++ b/honeybeetest/helpers.go
@@ -3,6 +3,7 @@ package honeybeetest
 import (
 	"bytes"
 	"github.com/stretchr/testify/assert"
+	"io"
 	"testing"
 	"time"
 )
@@ -28,6 +29,50 @@ type MockOutgoingData struct {
 	Data    []byte
 }
 
+// Setup
+
+func SetupTestSocket(t *testing.T) (
+	socket *MockSocket,
+	incoming chan MockIncomingData,
+	outgoing chan MockOutgoingData,
+) {
+	t.Helper()
+
+	incoming = make(chan MockIncomingData, 10)
+	outgoing = make(chan MockOutgoingData, 10)
+	socket = NewMockSocket()
+
+	socket.CloseFunc = func() error {
+		socket.Once.Do(func() { close(socket.Closed) })
+		return nil
+	}
+
+	socket.ReadMessageFunc = func() (int, []byte, error) {
+		select {
+		case data, ok := <-incoming:
+			if !ok {
+				return 0, nil, io.EOF
+			}
+			return data.MsgType, data.Data, data.Err
+		case <-socket.Closed:
+			return 0, nil, io.EOF
+		}
+	}
+
+	socket.WriteMessageFunc = func(msgType int, data []byte) error {
+		select {
+		case outgoing <- MockOutgoingData{MsgType: msgType, Data: data}:
+			return nil
+		case <-socket.Closed:
+			return io.EOF
+		default:
+			return io.EOF
+		}
+	}
+
+	return
+}
+
 // Helpers
 
 func ExpectIncoming(t *testing.T, incoming <-chan []byte, expected []byte) {
diff --git a/inbound/helpers_test.go b/inbound/helpers_test.go
index 1b6c0da..d1cf8b4 100644
--- a/inbound/helpers_test.go
+++ b/inbound/helpers_test.go
@@ -4,52 +4,9 @@ import (
 	"git.wisehodl.dev/jay/go-honeybee/honeybeetest"
 	"git.wisehodl.dev/jay/go-honeybee/transport"
 	"github.com/stretchr/testify/assert"
-	"io"
 	"testing"
 )
 
-func setupTestSocket(t *testing.T) (
-	socket *honeybeetest.MockSocket,
-	incoming chan honeybeetest.MockIncomingData,
-	outgoing chan honeybeetest.MockOutgoingData,
-) {
-	t.Helper()
-
-	incoming = make(chan honeybeetest.MockIncomingData, 10)
-	outgoing = make(chan honeybeetest.MockOutgoingData, 10)
-	socket = honeybeetest.NewMockSocket()
-
-	socket.CloseFunc = func() error {
-		socket.Once.Do(func() { close(socket.Closed) })
-		return nil
-	}
-
-	socket.ReadMessageFunc = func() (int, []byte, error) {
-		select {
-		case data, ok := <-incoming:
-			if !ok {
-				return 0, nil, io.EOF
-			}
-			return data.MsgType, data.Data, data.Err
-		case <-socket.Closed:
-			return 0, nil, io.EOF
-		}
-	}
-
-	socket.WriteMessageFunc = func(msgType int, data []byte) error {
-		select {
-		case outgoing <- honeybeetest.MockOutgoingData{MsgType: msgType, Data: data}:
-			return nil
-		case <-socket.Closed:
-			return io.EOF
-		default:
-			return io.EOF
-		}
-	}
-
-	return
-}
-
 func setupTestConnection(t *testing.T) (
 	conn *transport.Connection,
 	socket *honeybeetest.MockSocket,
@@ -58,7 +15,7 @@ func setupTestConnection(t *testing.T) (
 ) {
 	t.Helper()
 
-	socket, incoming, outgoing = setupTestSocket(t)
+	socket, incoming, outgoing = honeybeetest.SetupTestSocket(t)
 
 	var err error
 	conn, err = transport.NewConnectionFromSocket(socket, nil, nil)
diff --git a/inbound/pool_test.go b/inbound/pool_test.go
index 02deb83..8be7ab2 100644
--- a/inbound/pool_test.go
+++ b/inbound/pool_test.go
@@ -44,7 +44,7 @@ func TestPoolAdd(t *testing.T) {
 		pool := setupPool(t)
 		defer pool.Close()
 
-		socket, _, _ := setupTestSocket(t)
+		socket, _, _ := honeybeetest.SetupTestSocket(t)
 		err := pool.Add("peer-1", socket)
 		assert.NoError(t, err)
 	})
@@ -53,7 +53,7 @@ func TestPoolAdd(t *testing.T) {
 		pool := setupPool(t)
 		defer pool.Close()
 
-		socket, _, _ := setupTestSocket(t)
+		socket, _, _ := honeybeetest.SetupTestSocket(t)
 		err := pool.Add("peer-1", socket)
 		assert.NoError(t, err)
 
@@ -64,8 +64,8 @@ func TestPoolAdd(t *testing.T) {
 		pool := setupPool(t)
 		defer pool.Close()
 
-		socket1, _, _ := setupTestSocket(t)
-		socket2, _, _ := setupTestSocket(t)
+		socket1, _, _ := honeybeetest.SetupTestSocket(t)
+		socket2, _, _ := honeybeetest.SetupTestSocket(t)
 
 		err := pool.Add("peer-1", socket1)
 		assert.NoError(t, err)
@@ -78,7 +78,7 @@ func TestPoolAdd(t *testing.T) {
 		pool := setupPool(t)
 		pool.Close()
 
-		socket, _, _ := setupTestSocket(t)
+		socket, _, _ := honeybeetest.SetupTestSocket(t)
 		err := pool.Add("peer-1", socket)
 		assert.ErrorIs(t, err, ErrPoolClosed)
 	})
@@ -89,8 +89,8 @@ func TestPoolReplace(t *testing.T) {
 		pool := setupPool(t)
 		defer pool.Close()
 
-		socket1, _, _ := setupTestSocket(t)
-		socket2, _, _ := setupTestSocket(t)
+		socket1, _, _ := honeybeetest.SetupTestSocket(t)
+		socket2, _, _ := honeybeetest.SetupTestSocket(t)
 
 		err := pool.Add("peer-1", socket1)
 		assert.NoError(t, err)
@@ -105,7 +105,7 @@ func TestPoolReplace(t *testing.T) {
 		pool := setupPool(t)
 		defer pool.Close()
 
-		socket, _, _ := setupTestSocket(t)
+		socket, _, _ := honeybeetest.SetupTestSocket(t)
 		err := pool.Replace("unknown", socket)
 		assert.ErrorIs(t, err, ErrPeerNotFound)
 	})
@@ -114,7 +114,7 @@ func TestPoolReplace(t *testing.T) {
 		pool := setupPool(t)
 		pool.Close()
 
-		socket, _, _ := setupTestSocket(t)
+		socket, _, _ := honeybeetest.SetupTestSocket(t)
 		err := pool.Replace("peer-1", socket)
 		assert.ErrorIs(t, err, ErrPoolClosed)
 	})
@@ -123,8 +123,8 @@ func TestPoolReplace(t *testing.T) {
 		pool := setupPool(t)
 		defer pool.Close()
 
-		socket1, _, _ := setupTestSocket(t)
-		socket2, _, _ := setupTestSocket(t)
+		socket1, _, _ := honeybeetest.SetupTestSocket(t)
+		socket2, _, _ := honeybeetest.SetupTestSocket(t)
 
 		err := pool.Add("peer-1", socket1)
 		assert.NoError(t, err)
@@ -148,7 +148,7 @@ func TestPoolRemove(t *testing.T) {
 		pool := setupPool(t)
 		defer pool.Close()
 
-		socket, _, _ := setupTestSocket(t)
+		socket, _, _ := honeybeetest.SetupTestSocket(t)
 		err := pool.Add("peer-1", socket)
 		assert.NoError(t, err)
 
@@ -178,7 +178,7 @@ func TestPoolRemove(t *testing.T) {
 		pool := setupPool(t)
 		defer pool.Close()
 
-		socket, _, _ := setupTestSocket(t)
+		socket, _, _ := honeybeetest.SetupTestSocket(t)
 		err := pool.Add("peer-1", socket)
 		assert.NoError(t, err)
 
@@ -202,7 +202,7 @@ func TestPoolSend(t *testing.T) {
 		pool := setupPool(t)
 		defer pool.Close()
 
-		socket, _, outgoing := setupTestSocket(t)
+		socket, _, outgoing := honeybeetest.SetupTestSocket(t)
 		err := pool.Add("peer-1", socket)
 		assert.NoError(t, err)
 
@@ -244,7 +244,7 @@ func TestPoolClose(t *testing.T) {
 		pool := setupPool(t)
 		pool.Close()
 
-		socket, _, _ := setupTestSocket(t)
+		socket, _, _ := honeybeetest.SetupTestSocket(t)
 		err := pool.Add("peer-1", socket)
 		assert.ErrorIs(t, err, ErrPoolClosed)
 	})
@@ -261,8 +261,8 @@ func TestPoolPeers(t *testing.T) {
 		pool := setupPool(t)
 		defer pool.Close()
 
-		socket1, _, _ := setupTestSocket(t)
-		socket2, _, _ := setupTestSocket(t)
+		socket1, _, _ := honeybeetest.SetupTestSocket(t)
+		socket2, _, _ := honeybeetest.SetupTestSocket(t)
 
 		pool.Add("peer-1", socket1)
 		pool.Add("peer-2", socket2)
@@ -276,7 +276,7 @@ func TestPoolPeers(t *testing.T) {
 		pool := setupPool(t)
 		defer pool.Close()
 
-		socket, _, _ := setupTestSocket(t)
+		socket, _, _ := honeybeetest.SetupTestSocket(t)
 		pool.Add("peer-1", socket)
 		pool.Remove("peer-1")
 
@@ -287,7 +287,7 @@ func TestPoolPeers(t *testing.T) {
 		pool := setupPool(t)
 		defer pool.Close()
 
-		socket, incoming, _ := setupTestSocket(t)
+		socket, incoming, _ := honeybeetest.SetupTestSocket(t)
 		pool.Add("peer-1", socket)
 
 		close(incoming)
@@ -303,7 +303,7 @@ func TestPoolEvents(t *testing.T) {
 		pool := setupPool(t)
 		defer pool.Close()
 
-		socket, incoming, _ := setupTestSocket(t)
+		socket, incoming, _ := honeybeetest.SetupTestSocket(t)
 		pool.Add("peer-1", socket)
 
 		incoming <- honeybeetest.MockIncomingData{
@@ -321,7 +321,7 @@ func TestPoolEvents(t *testing.T) {
 		pool := setupPool(t)
 		defer pool.Close()
 
-		socket, incoming, _ := setupTestSocket(t)
+		socket, incoming, _ := honeybeetest.SetupTestSocket(t)
 		pool.Add("peer-1", socket)
 
 		incoming <- honeybeetest.MockIncomingData{
@@ -345,7 +345,7 @@ func TestPoolEvents(t *testing.T) {
 		assert.NoError(t, err)
 		defer pool.Close()
 
-		socket, _, _ := setupTestSocket(t)
+		socket, _, _ := honeybeetest.SetupTestSocket(t)
 		pool.Add("peer-1", socket)
 
 		expectEvent(t, pool.Events(), "peer-1", EventPeerEvicted)
@@ -359,7 +359,7 @@ func TestPoolEvents(t *testing.T) {
 		pool := setupPool(t)
 		defer pool.Close()
 
-		socket, _, _ := setupTestSocket(t)
+		socket, _, _ := honeybeetest.SetupTestSocket(t)
 		pool.Add("peer-1", socket)
 		pool.Remove("peer-1")
 
@@ -377,8 +377,8 @@ func TestPoolEvents(t *testing.T) {
 		pool := setupPool(t)
 		defer pool.Close()
 
-		socket1, _, _ := setupTestSocket(t)
-		socket2, _, _ := setupTestSocket(t)
+		socket1, _, _ := honeybeetest.SetupTestSocket(t)
+		socket2, _, _ := honeybeetest.SetupTestSocket(t)
 
 		pool.Add("peer-1", socket1)
 		pool.Replace("peer-1", socket2)
diff --git a/outbound/helper_test.go b/outbound/helper_test.go
index 7fa555d..0cda7c1 100644
--- a/outbound/helper_test.go
+++ b/outbound/helper_test.go
@@ -1,56 +1,24 @@
 package outbound
 
 import (
-	"fmt"
 	"git.wisehodl.dev/jay/go-honeybee/honeybeetest"
 	"git.wisehodl.dev/jay/go-honeybee/transport"
 	"github.com/stretchr/testify/assert"
-	"io"
 	"testing"
 )
 
 func setupTestConnection(t *testing.T) (
 	conn *transport.Connection,
-	mockSocket *honeybeetest.MockSocket,
-	incomingData chan honeybeetest.MockIncomingData,
-	outgoingData chan honeybeetest.MockOutgoingData,
+	socket *honeybeetest.MockSocket,
+	incoming chan honeybeetest.MockIncomingData,
+	outgoing chan honeybeetest.MockOutgoingData,
 ) {
 	t.Helper()
 
-	incomingData = make(chan honeybeetest.MockIncomingData, 10)
-	outgoingData = make(chan honeybeetest.MockOutgoingData, 10)
-	mockSocket = honeybeetest.NewMockSocket()
-
-	mockSocket.CloseFunc = func() error {
-		mockSocket.Once.Do(func() { close(mockSocket.Closed) })
-		return nil
-	}
-
-	mockSocket.ReadMessageFunc = func() (int, []byte, error) {
-		select {
-		case data, ok := <-incomingData:
-			if !ok {
-				return 0, nil, io.EOF
-			}
-			return data.MsgType, data.Data, data.Err
-		case <-mockSocket.Closed:
-			return 0, nil, io.EOF
-		}
-	}
-
-	mockSocket.WriteMessageFunc = func(msgType int, data []byte) error {
-		select {
-		case outgoingData <- honeybeetest.MockOutgoingData{MsgType: msgType, Data: data}:
-			return nil
-		case <-mockSocket.Closed:
-			return io.EOF
-		default:
-			return fmt.Errorf("mock outgoing channel unavailable")
-		}
-	}
+	socket, incoming, outgoing = honeybeetest.SetupTestSocket(t)
 
 	var err error
-	conn, err = transport.NewConnectionFromSocket(mockSocket, nil, nil)
+	conn, err = transport.NewConnectionFromSocket(socket, nil, nil)
 	assert.NoError(t, err)
 	return
 }
diff --git a/transport/connection_close_test.go b/transport/connection_close_test.go
index fbd2206..89a591b 100644
--- a/transport/connection_close_test.go
+++ b/transport/connection_close_test.go
@@ -80,7 +80,7 @@ func TestDisconnectedConnectionClose(t *testing.T) {
 
 func TestConnectedConnectionClose(t *testing.T) {
 	t.Run("blocked on ReadMessage, unblocks on closed", func(t *testing.T) {
-		conn, _, incomingData, _ := setupTestConnection(t, nil)
+		conn, _, incomingData, _ := setupTestConnection(t)
 
 		// Send a message to ensure reader loop is blocking
 		canary := []byte("canary")
diff --git a/transport/connection_goroutine_test.go b/transport/connection_goroutine_test.go
index ad696d5..b7cef5f 100644
--- a/transport/connection_goroutine_test.go
+++ b/transport/connection_goroutine_test.go
@@ -10,7 +10,7 @@ import (
 
 func TestStartReader(t *testing.T) {
 	t.Run("text messages route to incoming channel", func(t *testing.T) {
-		conn, _, incomingData, _ := setupTestConnection(t, nil)
+		conn, _, incomingData, _ := setupTestConnection(t)
 		defer conn.Close()
 
 		testData := []byte("hello")
@@ -24,7 +24,7 @@ func TestStartReader(t *testing.T) {
 	})
 
 	t.Run("binary messages route to incoming channel", func(t *testing.T) {
-		conn, _, incomingData, _ := setupTestConnection(t, nil)
+		conn, _, incomingData, _ := setupTestConnection(t)
 		defer conn.Close()
 
 		testData := []byte{0x00, 0x01, 0x02}
@@ -38,7 +38,7 @@ func TestStartReader(t *testing.T) {
 	})
 
 	t.Run("multiple messages processed sequentially", func(t *testing.T) {
-		conn, _, incomingData, _ := setupTestConnection(t, nil)
+		conn, _, incomingData, _ := setupTestConnection(t)
 		defer conn.Close()
 
 		messages := [][]byte{[]byte("first"), []byte("second"), []byte("third")}
diff --git a/transport/connection_send_test.go b/transport/connection_send_test.go
index d556eec..ada8823 100644
--- a/transport/connection_send_test.go
+++ b/transport/connection_send_test.go
@@ -13,7 +13,7 @@ import (
 
 func TestConnectionSend(t *testing.T) {
 	t.Run("writes message to socket", func(t *testing.T) {
-		conn, _, _, outgoingData := setupTestConnection(t, nil)
+		conn, _, _, outgoingData := setupTestConnection(t)
 		defer conn.Close()
 
 		testData := []byte("test message")
@@ -24,7 +24,7 @@ func TestConnectionSend(t *testing.T) {
 	})
 
 	t.Run("writes multiple message to socket", func(t *testing.T) {
-		conn, _, _, outgoingData := setupTestConnection(t, nil)
+		conn, _, _, outgoingData := setupTestConnection(t)
 		defer conn.Close()
 
 		messages := [][]byte{[]byte("first"), []byte("second"), []byte("third")}
@@ -39,7 +39,7 @@ func TestConnectionSend(t *testing.T) {
 	})
 
 	t.Run("concurrent sends write messages to socket", func(t *testing.T) {
-		conn, _, _, outgoingData := setupTestConnection(t, nil)
+		conn, _, _, outgoingData := setupTestConnection(t)
 		defer conn.Close()
 
 		mu := sync.Mutex{}
@@ -92,7 +92,7 @@ func TestConnectionSend(t *testing.T) {
 	})
 
 	t.Run("send fails when connection is closed", func(t *testing.T) {
-		conn, _, _, _ := setupTestConnection(t, nil)
+		conn, _, _, _ := setupTestConnection(t)
 		conn.Close()
 
 		testData := []byte("test message")
diff --git a/transport/connection_test.go b/transport/connection_test.go
index 95cc1b9..3ad58f8 100644
--- a/transport/connection_test.go
+++ b/transport/connection_test.go
@@ -539,54 +539,18 @@ func TestConnectionErrors(t *testing.T) {
 
 // Test helpers
 
-func setupTestConnection(t *testing.T, config *ConnectionConfig) (
+func setupTestConnection(t *testing.T) (
 	conn *Connection,
-	mockSocket *honeybeetest.MockSocket,
-	incomingData chan honeybeetest.MockIncomingData,
-	outgoingData chan honeybeetest.MockOutgoingData,
+	socket *honeybeetest.MockSocket,
+	incoming chan honeybeetest.MockIncomingData,
+	outgoing chan honeybeetest.MockOutgoingData,
 ) {
 	t.Helper()
 
-	incomingData = make(chan honeybeetest.MockIncomingData, 10)
-	outgoingData = make(chan honeybeetest.MockOutgoingData, 10)
-
-	mockSocket = honeybeetest.NewMockSocket()
-
-	mockSocket.CloseFunc = func() error {
-		mockSocket.Once.Do(func() {
-			close(mockSocket.Closed)
-		})
-		return nil
-	}
-
-	// Wire ReadMessage to pull from incomingData channel
-	mockSocket.ReadMessageFunc = func() (int, []byte, error) {
-		select {
-		case data, ok := <-incomingData:
-			if !ok {
-				return 0, nil, io.EOF
-			}
-			return data.MsgType, data.Data, data.Err
-		case <-mockSocket.Closed:
-			return 0, nil, io.EOF
-		}
-	}
-
-	// Wire WriteMessage to push to outgoingData channel
-	mockSocket.WriteMessageFunc = func(msgType int, data []byte) error {
-		select {
-		case outgoingData <- honeybeetest.MockOutgoingData{MsgType: msgType, Data: data}:
-			return nil
-		case <-mockSocket.Closed:
-			return io.EOF
-		default:
-			return fmt.Errorf("mock outgoing chanel unavailable")
-		}
-	}
+	socket, incoming, outgoing = honeybeetest.SetupTestSocket(t)
 
 	var err error
-	conn, err = NewConnectionFromSocket(mockSocket, config, nil)
+	conn, err = NewConnectionFromSocket(socket, nil, nil)
 	assert.NoError(t, err)
-
-	return conn, mockSocket, incomingData, outgoingData
+	return
 }