Documentation review

client/config.go

@@ -23,6 +23,7 @@ func defaultConfig() *Cfg {
 		hooks:             &hooks{},
 		HeartbeatInterval: 5 * time.Second,
 		MaxConcurrency:    10,
+		TargetServer:      "127.0.0.1:8080",
 	}
 	return cfg
 }

client_side_broadcast_test.go

@@ -35,7 +35,7 @@ func TestUserCanConfigureBroadcastHandler(t *testing.T) {
 			arbiter.ErrorHappened(err)
 			return
 		}
-		_, err = s.BroadCast(context.TODO(), message.New().SetPayload(oMsg))
+		_, err = s.Broadcast(context.TODO(), message.New().SetPayload(oMsg))
 		if err != nil {
 			arbiter.ErrorHappened(err)
 			return

internal/lab/server/main.go

@@ -93,7 +93,7 @@ func interactions(ctx context.Context, s *server.MeteredServer) {
 		case <-ctx.Done():
 			return
 		default:
-			_, err := s.BroadCast(context.Background(), message.New().SetPayload(&protos.BroadcastV1{
+			_, err := s.Broadcast(context.Background(), message.New().SetPayload(&protos.BroadcastV1{
 				Message: "Broadcasting !",
 				Data:    bytes,
 			}))

lifecycle_client_test.go

@@ -182,7 +182,7 @@ func TestClientHandlerCannotSendIfClosed(t *testing.T) {
 
 	// We provoke the handler execution of the client
 	// with a broadcast message.
-	_, err := s.BroadCast(defaultCtx, defaultMsg)
+	_, err := s.Broadcast(defaultCtx, defaultMsg)
 	require.NoError(t, err)
 
 	// We close the client, now the internal status changed.

lifecycle_server_test.go

@@ -98,15 +98,15 @@ func TestServerCannotSendMessagesIfNotRunning(t *testing.T) {
 
 	s, run := PrepareServer(t)
 
-	_, err := s.BroadCast(defaultCtx, defaultMsg)
+	_, err := s.Broadcast(defaultCtx, defaultMsg)
 	assert.ErrorIs(t, err, server.ErrNotRunning, "should not broadcast messages if not connected")
 
 	run()
 
 	err = s.Shutdown(defaultCtx)
 	require.NoError(t, err)
 
-	_, err = s.BroadCast(defaultCtx, defaultMsg)
+	_, err = s.Broadcast(defaultCtx, defaultMsg)
 	assert.ErrorIs(t, err, server.ErrNotRunning, "should not broadcast messages on closed status")
 }
 

multi_comm_test.go

@@ -31,7 +31,7 @@ func TestServerCanBroadCastMessages(t *testing.T) {
 		arbiter.ItsAFactThat("CLIENT2_RECEIVED_SERVER_GREET")
 	}))
 	connect2()
-	brResult, err := s.BroadCast(defaultCtx, defaultMsg)
+	brResult, err := s.Broadcast(defaultCtx, defaultMsg)
 	require.NoError(t, err)
 	require.Len(t, brResult, 2)
 	require.Equal(t, 12, brResult[0].Size)

pool_test.go

@@ -49,7 +49,7 @@ func WorkerPoolTest(maxConcurrency int, shouldBeActive bool) func(t *testing.T)
 
 		_, err := c.Send(defaultMsg)
 		require.NoError(t, err)
-		_, err = s.BroadCast(defaultCtx, defaultMsg)
+		_, err = s.Broadcast(defaultCtx, defaultMsg)
 		require.NoError(t, err)
 		if shouldBeActive {
 			arbiter.RequireHappenedInOrder(

racy_test.go

@@ -51,11 +51,11 @@ func TestNoRaces(t *testing.T) {
 	// Stress all parts of the system through the public API. All uses cases at the same time.
 	const maxConcurrent = 20
 	go exec.Parallelize(ctx, wg, maxConcurrent, func() {
-		if _, err := s.BroadCast(defaultCtx, defaultMsg); err != nil && err != server.ErrNotRunning {
+		if _, err := s.Broadcast(defaultCtx, defaultMsg); err != nil && err != server.ErrNotRunning {
 			arbiter.ErrorHappened(err)
 			return
 		}
-		arbiter.ItsAFactThat("s.BroadCast()")
+		arbiter.ItsAFactThat("s.Broadcast()")
 	})
 
 	go exec.Parallelize(ctx, wg, maxConcurrent, func() {

server/config.go

@@ -22,6 +22,7 @@ type Cfg struct {
 func defaultConfig() *Cfg {
 	cfg := &Cfg{
 		hooks:          &hooks{},
+		ListenURL:      "127.0.0.1:8080",
 		MaxConcurrency: 10,
 	}
 	return cfg

server/metered.go

@@ -56,9 +56,9 @@ func (s *MeteredServer) Handle(msg proto.Message, handler message.Handler) {
 	s.s.Handle(msg, handler)
 }
 
-func (s *MeteredServer) BroadCast(ctx context.Context, msg *message.Message) (brResult []BroadcastResult, err error) {
+func (s *MeteredServer) Broadcast(ctx context.Context, msg *message.Message) (brResult []BroadcastResult, err error) {
 	start := time.Now()
-	brResult, err = s.s.BroadCast(ctx, msg)
+	brResult, err = s.s.Broadcast(ctx, msg)
 	if err != nil {
 		s.metrics.Errors.Inc()
 		return

server/server.go

@@ -106,7 +106,7 @@ type BroadcastResult struct {
 	Duration time.Duration
 }
 
-// BroadCast will try to send the provided message to all
+// Broadcast will try to send the provided message to all
 // connected clients.
 //
 // In case the provided context is canceled, the operation
@@ -123,7 +123,7 @@ type BroadcastResult struct {
 // feedback, such as time distribution.
 //
 // Calling this method it's intended to be thread safe.
-func (s *Server) BroadCast(ctx context.Context, msg *message.Message) (brResult []BroadcastResult, err error) {
+func (s *Server) Broadcast(ctx context.Context, msg *message.Message) (brResult []BroadcastResult, err error) {
 	if s.status() != ws.StatusRunning {
 		return []BroadcastResult{}, ErrNotRunning
 	}