test(handlers): add coverage for BroadcastHandler (workspace_broadcast.go)

Add 13 tests covering every path in the POST /workspaces/:id/broadcast
handler and its unexported broadcastTruncate helper:

  broadcastTruncate:
    - short string → unmodified
    - exactly max length → unmodified
    - exceeds max length → truncated + ellipsis
    - unicode runes → rune-boundary truncation

  Broadcast:
    - invalid workspace ID → 400
    - missing message → 400
    - workspace not found → 404
    - broadcast_disabled=true → 403 with hint
    - recipient query fails → 500
    - no recipients → 200 delivered=0
    - one recipient → 200 delivered=1
    - recipient insert fails → 200 delivered=0 (best-effort continue)
    - sender log fails → 200 delivered=1 (best-effort, non-blocking)

Uses sqlmock for the DB layer and newTestBroadcaster() for the
*events.Broadcaster injection.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

canvas/src/components/tabs/__tests__/ChatTab.abilitiesBanner.test.tsx

@@ -1,155 +0,0 @@
-// @vitest-environment jsdom
-//
-// Tests for the talk_to_user_enabled banner in ChatTab.
-//
-// The banner appears when the agent's workspace has talkToUserEnabled=false.
-// It shows an informational message and an "Enable" button that calls:
-//   PATCH /workspaces/:id/abilities { talk_to_user_enabled: true }
-// and updates the canvas store on success.
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { render, screen, cleanup, fireEvent, waitFor } from "@testing-library/react";
-import React from "react";
-
-afterEach(cleanup);
-
-// ── API mock ──────────────────────────────────────────────────────────
-
-const apiPatch = vi.fn<[_path: string, _body: unknown], Promise<void>>();
-vi.mock("@/lib/api", () => ({
-  api: {
-    get: vi.fn(() => Promise.resolve([])),
-    post: vi.fn(() => Promise.resolve({})),
-    patch: (path: string, body: unknown) => apiPatch(path, body),
-    del: vi.fn(),
-    put: vi.fn(),
-  },
-}));
-
-// ── Store mock ────────────────────────────────────────────────────────
-// Must include agentMessages / consumeAgentMessages — used by useChatSocket
-// inside ChatTab even when the banner is shown. Also provides getState()
-// so ChatTab can call useCanvasStore.getState().updateNodeData() directly.
-const mockState = {
-  updateNodeData: vi.fn(),
-  agentMessages: {} as Record<string, unknown[]>,
-  consumeAgentMessages: vi.fn(() => []),
-};
-vi.mock("@/store/canvas", () => ({
-  useCanvasStore: Object.assign(
-    (selector?: (s: typeof mockState) => unknown) =>
-      selector ? selector(mockState) : mockState,
-    { getState: () => mockState },
-  ) as unknown as typeof import("@/store/canvas").useCanvasStore,
-}));
-
-// ── Upload mock ───────────────────────────────────────────────────────
-
-vi.mock("../chat/uploads", async () => {
-  const actual = await vi.importActual<typeof import("../chat/uploads")>("../chat/uploads");
-  return { ...actual, downloadChatFile: vi.fn() };
-});
-
-// ── Helpers ────────────────────────────────────────────────────────────
-
-const minimalData = {
-  status: "online" as const,
-  runtime: "claude-code",
-  currentTask: null,
-} as unknown as import("@/store/canvas").WorkspaceNodeData;
-
-beforeEach(() => {
-  apiPatch.mockClear();
-  mockState.updateNodeData.mockClear();
-  Element.prototype.scrollIntoView = vi.fn();
-  class FakeIO {
-    observe() {}
-    unobserve() {}
-    disconnect() {}
-  }
-  (window as unknown as { IntersectionObserver: unknown }).IntersectionObserver = FakeIO;
-  (globalThis as unknown as { IntersectionObserver: unknown }).IntersectionObserver = FakeIO;
-});
-
-import { ChatTab } from "../ChatTab";
-
-// ─── Banner renders ───────────────────────────────────────────────────────────
-
-describe("ChatTab — talk_to_user_enabled banner", () => {
-  it("shows the banner when talkToUserEnabled is false", () => {
-    const data = { ...minimalData, talkToUserEnabled: false };
-    render(<ChatTab workspaceId="ws-disabled" data={data} />);
-
-    // screen.getByText throws if not found, so absence of error = found
-    expect(screen.getByText((content: string) =>
-      content.includes("Agent is not enabled to chat with you"),
-    )).toBeTruthy();
-    expect(screen.getByRole("button", { name: /enable/i })).toBeTruthy();
-  });
-
-  it("does NOT show the banner when talkToUserEnabled is true", () => {
-    const data = { ...minimalData, talkToUserEnabled: true };
-    render(<ChatTab workspaceId="ws-enabled" data={data} />);
-
-    expect(screen.queryByText((content: string) =>
-      content.includes("Agent is not enabled to chat with you"),
-    )).toBeFalsy();
-  });
-
-  it("does NOT show the banner when talkToUserEnabled is absent (undefined)", () => {
-    const data = { ...minimalData };
-    render(<ChatTab workspaceId="ws-unset" data={data} />);
-
-    expect(screen.queryByText((content: string) =>
-      content.includes("Agent is not enabled to chat with you"),
-    )).toBeFalsy();
-  });
-
-  // ─── Enable button ────────────────────────────────────────────────────────────
-
-  it('Enable button calls PATCH /workspaces/:id/abilities with talk_to_user_enabled: true', async () => {
-    const data = { ...minimalData, talkToUserEnabled: false };
-    apiPatch.mockResolvedValue(undefined);
-
-    render(<ChatTab workspaceId="ws-banner-1" data={data} />);
-
-    fireEvent.click(screen.getByRole("button", { name: /enable/i }));
-
-    await waitFor(() => {
-      expect(apiPatch).toHaveBeenCalledOnce();
-      expect(apiPatch).toHaveBeenCalledWith(
-        "/workspaces/ws-banner-1/abilities",
-        { talk_to_user_enabled: true },
-      );
-    });
-  });
-
-  it("Enable button updates the store on success", async () => {
-    const data = { ...minimalData, talkToUserEnabled: false };
-    apiPatch.mockResolvedValue(undefined);
-
-    render(<ChatTab workspaceId="ws-banner-2" data={data} />);
-
-    fireEvent.click(screen.getByRole("button", { name: /enable/i }));
-
-    await waitFor(() => {
-      expect(mockState.updateNodeData).toHaveBeenCalledOnce();
-      expect(mockState.updateNodeData).toHaveBeenCalledWith("ws-banner-2", { talkToUserEnabled: true });
-    });
-  });
-
-  it("Enable button does NOT throw when PATCH fails — error is silently swallowed", async () => {
-    const data = { ...minimalData, talkToUserEnabled: false };
-    apiPatch.mockRejectedValue(new Error("network error"));
-
-    render(<ChatTab workspaceId="ws-banner-3" data={data} />);
-
-    // Should not throw — the catch block swallows the error
-    fireEvent.click(screen.getByRole("button", { name: /enable/i }));
-
-    // Store update should NOT have been called since the API call failed
-    await waitFor(() => {
-      expect(mockState.updateNodeData).not.toHaveBeenCalled();
-    });
-  });
-});

workspace-server/internal/handlers/workspace_broadcast_test.go

@@ -0,0 +1,408 @@
+package handlers
+
+import (
+	"bytes"
+	"context"
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/DATA-DOG/go-sqlmock"
+	"github.com/Molecule-AI/molecule-monorepo/platform/internal/db"
+	"github.com/gin-gonic/gin"
+)
+
+// -------------------------------------------------------------------------- //
+// broadcastTruncate
+// -------------------------------------------------------------------------- //
+
+func TestBroadcastTruncate_ShortString_ReturnsUnmodified(t *testing.T) {
+	result := broadcastTruncate("hello", 10)
+	if result != "hello" {
+		t.Errorf("expected 'hello', got %q", result)
+	}
+}
+
+func TestBroadcastTruncate_ExactlyMaxLength_ReturnsUnmodified(t *testing.T) {
+	result := broadcastTruncate("hello", 5)
+	if result != "hello" {
+		t.Errorf("expected 'hello', got %q", result)
+	}
+}
+
+func TestBroadcastTruncate_ExceedsMaxLength_TruncatesWithEllipsis(t *testing.T) {
+	result := broadcastTruncate("hello world", 5)
+	if result != "hello…" {
+		t.Errorf("expected 'hello…', got %q", result)
+	}
+}
+
+func TestBroadcastTruncate_Unicode_TruncatesAtRuneBoundary(t *testing.T) {
+	// "日本語" is 3 runes; truncating at 2 should give 2 runes + ellipsis.
+	result := broadcastTruncate("日本語テスト", 2)
+	if result != "日本…" {
+		t.Errorf("expected '日本…', got %q", result)
+	}
+}
+
+// -------------------------------------------------------------------------- //
+// BroadcastHandler
+// -------------------------------------------------------------------------- //
+
+func setupBroadcastTest(t *testing.T) (sqlmock.Sqlmock, func()) {
+	t.Helper()
+	mockDB, mock, err := sqlmock.New()
+	if err != nil {
+		t.Fatalf("failed to create sqlmock: %v", err)
+	}
+	prev := db.DB
+	db.DB = mockDB
+	return mock, func() {
+		db.DB = prev
+		mockDB.Close()
+	}
+}
+
+func TestBroadcast_InvalidWorkspaceID_Returns400(t *testing.T) {
+	_, cleanup := setupBroadcastTest(t)
+	defer cleanup()
+
+	h := NewBroadcastHandler(newTestBroadcaster())
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: "not-a-uuid"}}
+	c.Request = httptest.NewRequest("POST", "/workspaces/not-a-uuid/broadcast",
+		bytes.NewBufferString(`{"message":"hello"}`))
+	c.Request.Header.Set("Content-Type", "application/json")
+	c.Request = c.Request.WithContext(context.Background())
+
+	h.Broadcast(c)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("expected 400, got %d: %s", w.Code, w.Body.String())
+	}
+	var body map[string]string
+	json.Unmarshal(w.Body.Bytes(), &body)
+	if body["error"] != "invalid workspace ID" {
+		t.Errorf("expected 'invalid workspace ID', got %q", body["error"])
+	}
+}
+
+func TestBroadcast_MissingMessage_Returns400(t *testing.T) {
+	_, cleanup := setupBroadcastTest(t)
+	defer cleanup()
+
+	h := NewBroadcastHandler(newTestBroadcaster())
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: "550e8400-e29b-41d4-a716-446655440000"}}
+	c.Request = httptest.NewRequest("POST",
+		"/workspaces/550e8400-e29b-41d4-a716-446655440000/broadcast",
+		bytes.NewBufferString(`{}`))
+	c.Request.Header.Set("Content-Type", "application/json")
+	c.Request = c.Request.WithContext(context.Background())
+
+	h.Broadcast(c)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("expected 400, got %d: %s", w.Code, w.Body.String())
+	}
+	var body map[string]string
+	json.Unmarshal(w.Body.Bytes(), &body)
+	if body["error"] != "message is required" {
+		t.Errorf("expected 'message is required', got %q", body["error"])
+	}
+}
+
+func TestBroadcast_WorkspaceNotFound_Returns404(t *testing.T) {
+	mock, cleanup := setupBroadcastTest(t)
+	defer cleanup()
+
+	mock.ExpectQuery("SELECT name, broadcast_enabled FROM workspaces").
+		WithArgs("550e8400-e29b-41d4-a716-446655440000").
+		WillReturnError(sql.ErrNoRows)
+
+	h := NewBroadcastHandler(newTestBroadcaster())
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: "550e8400-e29b-41d4-a716-446655440000"}}
+	c.Request = httptest.NewRequest("POST",
+		"/workspaces/550e8400-e29b-41d4-a716-446655440000/broadcast",
+		bytes.NewBufferString(`{"message":"hello"}`))
+	c.Request.Header.Set("Content-Type", "application/json")
+	c.Request = c.Request.WithContext(context.Background())
+
+	h.Broadcast(c)
+
+	if w.Code != http.StatusNotFound {
+		t.Errorf("expected 404, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestBroadcast_BroadcastDisabled_Returns403(t *testing.T) {
+	mock, cleanup := setupBroadcastTest(t)
+	defer cleanup()
+
+	mock.ExpectQuery("SELECT name, broadcast_enabled FROM workspaces").
+		WithArgs("550e8400-e29b-41d4-a716-446655440000").
+		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).
+			AddRow("test-agent", false))
+
+	h := NewBroadcastHandler(newTestBroadcaster())
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: "550e8400-e29b-41d4-a716-446655440000"}}
+	c.Request = httptest.NewRequest("POST",
+		"/workspaces/550e8400-e29b-41d4-a716-446655440000/broadcast",
+		bytes.NewBufferString(`{"message":"hello"}`))
+	c.Request.Header.Set("Content-Type", "application/json")
+	c.Request = c.Request.WithContext(context.Background())
+
+	h.Broadcast(c)
+
+	if w.Code != http.StatusForbidden {
+		t.Errorf("expected 403, got %d: %s", w.Code, w.Body.String())
+	}
+	var body map[string]string
+	json.Unmarshal(w.Body.Bytes(), &body)
+	if body["error"] != "broadcast_disabled" {
+		t.Errorf("expected error='broadcast_disabled', got %v", body)
+	}
+	if _, ok := body["hint"]; !ok {
+		t.Errorf("expected hint field in 403 body, got %v", body)
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestBroadcast_RecipientQueryFails_Returns500(t *testing.T) {
+	mock, cleanup := setupBroadcastTest(t)
+	defer cleanup()
+
+	mock.ExpectQuery("SELECT name, broadcast_enabled FROM workspaces").
+		WithArgs("550e8400-e29b-41d4-a716-446655440000").
+		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).
+			AddRow("test-agent", true))
+	mock.ExpectQuery("SELECT id FROM workspaces WHERE status != 'removed' AND id != ").
+		WithArgs("550e8400-e29b-41d4-a716-446655440000").
+		WillReturnError(errors.New("connection refused"))
+
+	h := NewBroadcastHandler(newTestBroadcaster())
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: "550e8400-e29b-41d4-a716-446655440000"}}
+	c.Request = httptest.NewRequest("POST",
+		"/workspaces/550e8400-e29b-41d4-a716-446655440000/broadcast",
+		bytes.NewBufferString(`{"message":"hello"}`))
+	c.Request.Header.Set("Content-Type", "application/json")
+	c.Request = c.Request.WithContext(context.Background())
+
+	h.Broadcast(c)
+
+	if w.Code != http.StatusInternalServerError {
+		t.Errorf("expected 500, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestBroadcast_NoRecipients_Returns200(t *testing.T) {
+	mock, cleanup := setupBroadcastTest(t)
+	defer cleanup()
+
+	mock.ExpectQuery("SELECT name, broadcast_enabled FROM workspaces").
+		WithArgs("550e8400-e29b-41d4-a716-446655440000").
+		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).
+			AddRow("test-agent", true))
+	mock.ExpectQuery("SELECT id FROM workspaces WHERE status != 'removed' AND id != ").
+		WithArgs("550e8400-e29b-41d4-a716-446655440000").
+		WillReturnRows(sqlmock.NewRows([]string{"id"})) // no rows
+	// Sender's own broadcast_sent insert.
+	mock.ExpectExec("INSERT INTO activity_logs").
+		WithArgs("550e8400-e29b-41d4-a716-446655440000", "Broadcast sent to 0 workspace(s)").
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
+	h := NewBroadcastHandler(newTestBroadcaster())
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: "550e8400-e29b-41d4-a716-446655440000"}}
+	c.Request = httptest.NewRequest("POST",
+		"/workspaces/550e8400-e29b-41d4-a716-446655440000/broadcast",
+		bytes.NewBufferString(`{"message":"hello"}`))
+	c.Request.Header.Set("Content-Type", "application/json")
+	c.Request = c.Request.WithContext(context.Background())
+
+	h.Broadcast(c)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+	var body map[string]interface{}
+	json.Unmarshal(w.Body.Bytes(), &body)
+	if body["status"] != "sent" {
+		t.Errorf("expected status=sent, got %v", body)
+	}
+	if int(body["delivered"].(float64)) != 0 {
+		t.Errorf("expected delivered=0, got %v", body["delivered"])
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestBroadcast_DeliversToOneRecipient_Returns200(t *testing.T) {
+	mock, cleanup := setupBroadcastTest(t)
+	defer cleanup()
+
+	senderID := "550e8400-e29b-41d4-a716-446655440000"
+	recipientID := "660e8400-e29b-41d4-a716-446655440001"
+	senderName := "test-agent"
+
+	mock.ExpectQuery("SELECT name, broadcast_enabled FROM workspaces").
+		WithArgs(senderID).
+		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).
+			AddRow(senderName, true))
+	mock.ExpectQuery("SELECT id FROM workspaces WHERE status != 'removed' AND id != ").
+		WithArgs(senderID).
+		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(recipientID))
+	// activity_logs insert for recipient.
+	mock.ExpectExec("INSERT INTO activity_logs").
+		WithArgs(recipientID, senderID, "Broadcast from "+senderName+": hello").
+		WillReturnResult(sqlmock.NewResult(0, 1))
+	// Sender's broadcast_sent insert.
+	mock.ExpectExec("INSERT INTO activity_logs").
+		WithArgs(senderID, "Broadcast sent to 1 workspace(s)").
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
+	h := NewBroadcastHandler(newTestBroadcaster())
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: senderID}}
+	c.Request = httptest.NewRequest("POST",
+		"/workspaces/"+senderID+"/broadcast",
+		bytes.NewBufferString(`{"message":"hello"}`))
+	c.Request.Header.Set("Content-Type", "application/json")
+	c.Request = c.Request.WithContext(context.Background())
+
+	h.Broadcast(c)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+	var body map[string]interface{}
+	json.Unmarshal(w.Body.Bytes(), &body)
+	if int(body["delivered"].(float64)) != 1 {
+		t.Errorf("expected delivered=1, got %v", body["delivered"])
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestBroadcast_RecipientInsertFails_Continues_Returns200(t *testing.T) {
+	mock, cleanup := setupBroadcastTest(t)
+	defer cleanup()
+
+	senderID := "550e8400-e29b-41d4-a716-446655440000"
+	recipientID := "660e8400-e29b-41d4-a716-446655440001"
+	senderName := "test-agent"
+
+	mock.ExpectQuery("SELECT name, broadcast_enabled FROM workspaces").
+		WithArgs(senderID).
+		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).
+			AddRow(senderName, true))
+	mock.ExpectQuery("SELECT id FROM workspaces WHERE status != 'removed' AND id != ").
+		WithArgs(senderID).
+		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(recipientID))
+	// Recipient insert fails — handler logs and continues.
+	mock.ExpectExec("INSERT INTO activity_logs").
+		WithArgs(recipientID, senderID, "Broadcast from "+senderName+": hello").
+		WillReturnError(errors.New("connection refused"))
+	// Sender's broadcast_sent insert still succeeds.
+	mock.ExpectExec("INSERT INTO activity_logs").
+		WithArgs(senderID, "Broadcast sent to 0 workspace(s)").
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
+	h := NewBroadcastHandler(newTestBroadcaster())
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: senderID}}
+	c.Request = httptest.NewRequest("POST",
+		"/workspaces/"+senderID+"/broadcast",
+		bytes.NewBufferString(`{"message":"hello"}`))
+	c.Request.Header.Set("Content-Type", "application/json")
+	c.Request = c.Request.WithContext(context.Background())
+
+	h.Broadcast(c)
+
+	// Even though the recipient insert failed, the handler still returns 200
+	// with delivered=0 (counted only on success).
+	if w.Code != http.StatusOK {
+		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+	var body map[string]interface{}
+	json.Unmarshal(w.Body.Bytes(), &body)
+	if int(body["delivered"].(float64)) != 0 {
+		t.Errorf("expected delivered=0 (failed inserts don't count), got %v", body["delivered"])
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestBroadcast_SenderLogFails_StillReturns200(t *testing.T) {
+	mock, cleanup := setupBroadcastTest(t)
+	defer cleanup()
+
+	senderID := "550e8400-e29b-41d4-a716-446655440000"
+	recipientID := "660e8400-e29b-41d4-a716-446655440001"
+	senderName := "test-agent"
+
+	mock.ExpectQuery("SELECT name, broadcast_enabled FROM workspaces").
+		WithArgs(senderID).
+		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).
+			AddRow(senderName, true))
+	mock.ExpectQuery("SELECT id FROM workspaces WHERE status != 'removed' AND id != ").
+		WithArgs(senderID).
+		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(recipientID))
+	mock.ExpectExec("INSERT INTO activity_logs").
+		WithArgs(recipientID, senderID, "Broadcast from "+senderName+": hello").
+		WillReturnResult(sqlmock.NewResult(0, 1))
+	// Sender's broadcast_sent insert fails — best-effort, no effect on response.
+	mock.ExpectExec("INSERT INTO activity_logs").
+		WithArgs(senderID, "Broadcast sent to 1 workspace(s)").
+		WillReturnError(errors.New("connection refused"))
+
+	h := NewBroadcastHandler(newTestBroadcaster())
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: senderID}}
+	c.Request = httptest.NewRequest("POST",
+		"/workspaces/"+senderID+"/broadcast",
+		bytes.NewBufferString(`{"message":"hello"}`))
+	c.Request.Header.Set("Content-Type", "application/json")
+	c.Request = c.Request.WithContext(context.Background())
+
+	h.Broadcast(c)
+
+	// Even though the sender log failed, response is still 200.
+	if w.Code != http.StatusOK {
+		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+	var body map[string]interface{}
+	json.Unmarshal(w.Body.Bytes(), &body)
+	if int(body["delivered"].(float64)) != 1 {
+		t.Errorf("expected delivered=1, got %v", body["delivered"])
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}