jay/go-honeybee
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Created public api, cleaned up internals.

Browse Source
This commit is contained in:
Jay
2026-04-19 14:23:10 -04:00
parent d2528d3ac7
commit dfd28d65bc
7 changed files with 158 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files
initiatorpool/pool.go
+11 -3
View File
@@ -100,8 +100,15 @@ func NewPool(ctx context.Context, config *PoolConfig, logger *slog.Logger,
return p, nil
}
func (p *Pool) Peers() map[string]*Peer {
return p.peers
func (p *Pool) Peers() []string {
p.mu.RLock()
defer p.mu.RUnlock()
ids := make([]string, 0, len(p.peers))
for i, _ := range p.peers {
ids = append(ids, i)
}
return ids
}
func (p *Pool) Inbox() chan InboxMessage {
@@ -131,8 +138,9 @@ func (p *Pool) Close() {
}
p.closed = true
p.cancel()
p.cancel() // closes all workers
// remove all peers
p.peers = make(map[string]*Peer)
p.mu.Unlock()
initiatorpool/pool_test.go
+49 -107
View File
@@ -4,31 +4,31 @@ import (
"context"
"fmt"
"git.wisehodl.dev/jay/go-honeybee/honeybeetest"
"git.wisehodl.dev/jay/go-honeybee/transport"
"git.wisehodl.dev/jay/go-honeybee/types"
"github.com/gorilla/websocket"
"github.com/stretchr/testify/assert"
"net/http"
"testing"
"time"
)
// TODO: Worker must connect and emit events.
func _TestPoolConnect(t *testing.T) {
func setupPool(t *testing.T) (*Pool, *honeybeetest.MockDialer) {
t.Helper()
pool, err := NewPool(context.Background(), nil, nil)
assert.NoError(t, err)
dialer := &honeybeetest.MockDialer{
DialContextFunc: func(context.Context, string, http.Header) (types.Socket, *http.Response, error) {
return honeybeetest.NewMockSocket(), nil, nil
},
}
pool.dialer = dialer
return pool, dialer
}
func TestPoolConnect(t *testing.T) {
t.Run("successfully adds connection", func(t *testing.T) {
mockSocket := honeybeetest.NewMockSocket()
mockDialer := &honeybeetest.MockDialer{
DialContextFunc: func(context.Context, string, http.Header) (types.Socket, *http.Response, error) {
return mockSocket, nil, nil
},
}
pool, _ := setupPool(t)
pool, err := NewPool(context.Background(), nil, nil)
assert.NoError(t, err)
pool.dialer = mockDialer
err = pool.Connect("wss://test")
err := pool.Connect("wss://test")
assert.NoError(t, err)
honeybeetest.Eventually(t, func() bool {
@@ -40,25 +40,15 @@ func _TestPoolConnect(t *testing.T) {
}
}, "expected event")
_, exists := pool.peers["wss://test"]
assert.True(t, exists)
assert.Contains(t, pool.Peers(), "wss://test")
pool.Close()
})
t.Run("does not add duplicate", func(t *testing.T) {
mockSocket := honeybeetest.NewMockSocket()
mockDialer := &honeybeetest.MockDialer{
DialContextFunc: func(context.Context, string, http.Header) (types.Socket, *http.Response, error) {
return mockSocket, nil, nil
},
}
pool, _ := setupPool(t)
pool, err := NewPool(context.Background(), nil, nil)
assert.NoError(t, err)
pool.dialer = mockDialer
err = pool.Connect("wss://test")
err := pool.Connect("wss://test")
assert.NoError(t, err)
// trailing slash normalizes to same key
@@ -66,119 +56,71 @@ func _TestPoolConnect(t *testing.T) {
assert.Error(t, err)
assert.ErrorIs(t, err, ErrPeerExists)
pool.mu.RLock()
assert.Len(t, pool.peers, 1)
pool.mu.RUnlock()
pool.Close()
})
t.Run("fails to add connection", func(t *testing.T) {
pool, err := NewPool(
context.Background(),
&PoolConfig{
ConnectionConfig: &transport.ConnectionConfig{
Retry: &transport.RetryConfig{
MaxRetries: 1,
InitialDelay: 1 * time.Millisecond,
MaxDelay: 5 * time.Millisecond,
}},
}, nil)
assert.NoError(t, err)
pool.dialer = &honeybeetest.MockDialer{
DialContextFunc: func(context.Context, string, http.Header) (types.Socket, *http.Response, error) {
return nil, nil, fmt.Errorf("dial failed")
},
}
err = pool.Connect("wss://test")
assert.Error(t, err)
pool.mu.RLock()
assert.Len(t, pool.peers, 0)
pool.mu.RUnlock()
select {
case event := <-pool.events:
t.Fatalf("unexpected event: %+v", event)
default:
}
assert.Len(t, pool.Peers(), 1)
pool.Close()
})
}
// TODO: Worker must stop connection and emit events
func _TestPoolRemove(t *testing.T) {
t.Run("removes known url", func(t *testing.T) {
mockSocket := honeybeetest.NewMockSocket()
mockDialer := &honeybeetest.MockDialer{
DialContextFunc: func(context.Context, string, http.Header) (types.Socket, *http.Response, error) {
return mockSocket, nil, nil
},
}
func TestPoolClose(t *testing.T) {
t.Run("channels close after pool close", func(t *testing.T) {
pool, _ := NewPool(context.Background(), nil, nil)
pool.Close()
_, ok := <-pool.Inbox()
assert.False(t, ok)
_, ok = <-pool.Events()
assert.False(t, ok)
_, ok = <-pool.Errors()
assert.False(t, ok)
})
pool, err := NewPool(context.Background(), nil, nil)
assert.NoError(t, err)
pool.dialer = mockDialer
t.Run("connect after close returns error", func(t *testing.T) {
pool, _ := NewPool(context.Background(), nil, nil)
pool.Close()
err := pool.Connect("wss://test")
assert.ErrorIs(t, err, ErrPoolClosed)
})
}
func TestPoolRemove(t *testing.T) {
t.Run("removes known url", func(t *testing.T) {
pool, _ := setupPool(t)
pool.Connect("wss://test")
expectEvent(t, pool.events, "wss://test", EventConnected)
err = pool.Remove("wss://test/")
err := pool.Remove("wss://test/")
assert.NoError(t, err)
// expect a disconnected event
expectEvent(t, pool.events, "wss://test", EventDisconnected)
// connection no longer in pool
pool.mu.Lock()
defer pool.mu.Unlock()
_, ok := pool.peers["wss://peer2"]
assert.False(t, ok, "connection is still in pool")
assert.NotContains(t, pool.Peers(), "wss://test")
})
t.Run("unknown url returns error", func(t *testing.T) {
mockSocket := honeybeetest.NewMockSocket()
mockDialer := &honeybeetest.MockDialer{
DialContextFunc: func(context.Context, string, http.Header) (types.Socket, *http.Response, error) {
return mockSocket, nil, nil
},
}
pool, err := NewPool(context.Background(), nil, nil)
assert.NoError(t, err)
pool.dialer = mockDialer
pool, _ := setupPool(t)
// remove unknown connection
err = pool.Remove("wss://unknown")
err := pool.Remove("wss://unknown")
assert.ErrorIs(t, err, ErrPeerNotFound)
})
t.Run("closed pool returns error", func(t *testing.T) {
mockSocket := honeybeetest.NewMockSocket()
mockDialer := &honeybeetest.MockDialer{
DialContextFunc: func(context.Context, string, http.Header) (types.Socket, *http.Response, error) {
return mockSocket, nil, nil
},
}
pool, err := NewPool(context.Background(), nil, nil)
assert.NoError(t, err)
pool.dialer = mockDialer
pool, _ := setupPool(t)
// close pool
pool.Close()
// attempt to remove connection
err = pool.Remove("wss://test")
err := pool.Remove("wss://test")
assert.ErrorIs(t, err, ErrPoolClosed)
})
}
// TODO: update worker to be responsible for send
func _TestPoolSend(t *testing.T) {
func TestPoolSend(t *testing.T) {
mockSocket := honeybeetest.NewMockSocket()
outgoingData := make(chan honeybeetest.MockOutgoingData, 10)
mockSocket.WriteMessageFunc = func(msgType int, data []byte) error {
initiatorpool/worker_dialer_test.go
+5 -1
View File
@@ -8,6 +8,7 @@ import (
"git.wisehodl.dev/jay/go-honeybee/types"
"github.com/stretchr/testify/assert"
"net/http"
"sync"
"sync/atomic"
"testing"
"time"
@@ -57,11 +58,14 @@ func TestRunDialer(t *testing.T) {
mockSocket := honeybeetest.NewMockSocket()
connConfig := &transport.ConnectionConfig{Retry: nil} // disable retry
started := make(chan struct{})
startOnce := sync.Once{}
wctx := WorkerContext{
Errors: make(chan error, 1),
Dialer: &honeybeetest.MockDialer{
DialContextFunc: func(context.Context, string, http.Header) (types.Socket, *http.Response, error) {
dialCount.Add(1)
startOnce.Do(func() { close(started) })
<-gate
return mockSocket, nil, nil
},
@@ -73,7 +77,7 @@ func TestRunDialer(t *testing.T) {
dial <- struct{}{}
// wait for dial to start blocking on gate
time.Sleep(20 * time.Millisecond)
<-started
// flood dial while dialer is blocked
for i := 0; i < 5; i++ {
initiatorpool/worker_keepalive_test.go
+2 -2
View File
@@ -15,14 +15,14 @@ func TestRunKeepalive(t *testing.T) {
defer cancel()
w := &DefaultWorker{
Config: &WorkerConfig{KeepaliveTimeout: 100 * time.Millisecond},
Config: &WorkerConfig{KeepaliveTimeout: 200 * time.Millisecond},
Heartbeat: heartbeat,
}
go w.RunKeepalive(ctx, keepalive)
// send heartbeats faster than the timeout
for i := 0; i < 5; i++ {
time.Sleep(30 * time.Millisecond)
time.Sleep(20 * time.Millisecond)
w.Heartbeat <- struct{}{}
}