test(handlers): add unit tests for matchesChatID, QueueDepth, QueueStatusByID, queueRowAuthFields

- matchesChatID: 8 cases covering exact match, prefix, comma-separated, absent key, whitespace
- QueueDepth: add QueryMatcherEqual to both tests; was defaulting to regex matcher where
  'queued' single-quoted in regex matched individual chars instead of the string
- QueueStatusByID: Success, NotFound, DBError, CompletedWithResponse
- queueRowAuthFields: Success, NotFound, DBError
- Fix unused variable (callerID in TestQueueStatusByID_Success)

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

workspace-server/internal/handlers/a2a_queue_status_test.go

@@ -1,7 +1,12 @@
 package handlers
 
 import (
+	"context"
+	"database/sql"
 	"testing"
+
+	sqlmock "github.com/DATA-DOG/go-sqlmock"
+	"github.com/Molecule-AI/molecule-monorepo/platform/internal/db"
 )
 
 // TestExtractExpiresInSeconds covers the JSON parser used at enqueue time
@@ -58,3 +63,207 @@ func TestExtractExpiresInSeconds(t *testing.T) {
 		})
 	}
 }
+
+// ── QueueStatusByID ─────────────────────────────────────────────────────────────
+
+func setupQueueStatusDB(t *testing.T) sqlmock.Sqlmock {
+	t.Helper()
+	mockDB, mock, err := sqlmock.New()
+	if err != nil {
+		t.Fatalf("failed to create sqlmock: %v", err)
+	}
+	prevDB := db.DB
+	db.DB = mockDB
+	t.Cleanup(func() { db.DB = prevDB; mockDB.Close() })
+	return mock
+}
+
+func TestQueueStatusByID_Success(t *testing.T) {
+	mock := setupQueueStatusDB(t)
+	queueID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	wsID := "cccccccc-cccc-cccc-cccc-cccccccccccc"
+
+	rows := sqlmock.NewRows([]string{
+		"id", "workspace_id", "status", "priority", "attempts",
+		"last_error", "enqueued_at", "dispatched_at", "completed_at", "expires_at",
+		"response_body",
+	}).AddRow(
+		queueID, wsID, "queued", 50, 0,
+		nil,                    // last_error
+		"2026-01-01T00:00:00Z", // enqueued_at
+		nil,                    // dispatched_at
+		nil,                    // completed_at
+		nil,                    // expires_at
+		nil,                    // response_body
+	)
+	mock.ExpectQuery(`SELECT`).
+		WithArgs(queueID).
+		WillReturnRows(rows)
+
+	qs, err := QueueStatusByID(context.Background(), queueID)
+	if err != nil {
+		t.Fatalf("QueueStatusByID returned error: %v", err)
+	}
+	if qs.ID != queueID {
+		t.Errorf("ID = %q, want %q", qs.ID, queueID)
+	}
+	if qs.WorkspaceID != wsID {
+		t.Errorf("WorkspaceID = %q, want %q", qs.WorkspaceID, wsID)
+	}
+	if qs.Status != "queued" {
+		t.Errorf("Status = %q, want %q", qs.Status, "queued")
+	}
+	if qs.Priority != 50 {
+		t.Errorf("Priority = %d, want 50", qs.Priority)
+	}
+	if qs.LastError != nil {
+		t.Errorf("LastError = %v, want nil", qs.LastError)
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestQueueStatusByID_NotFound(t *testing.T) {
+	mock := setupQueueStatusDB(t)
+	queueID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+
+	mock.ExpectQuery(`SELECT`).
+		WithArgs(queueID).
+		WillReturnError(sql.ErrNoRows)
+
+	qs, err := QueueStatusByID(context.Background(), queueID)
+	if err != sql.ErrNoRows {
+		t.Errorf("expected sql.ErrNoRows, got %v", err)
+	}
+	if qs != nil {
+		t.Errorf("expected nil queue status, got %+v", qs)
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestQueueStatusByID_DBError(t *testing.T) {
+	mock := setupQueueStatusDB(t)
+	queueID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+
+	mock.ExpectQuery(`SELECT`).
+		WithArgs(queueID).
+		WillReturnError(sql.ErrConnDone)
+
+	qs, err := QueueStatusByID(context.Background(), queueID)
+	if err == nil {
+		t.Error("expected error, got nil")
+	}
+	if qs != nil {
+		t.Errorf("expected nil queue status, got %+v", qs)
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestQueueStatusByID_CompletedWithResponse(t *testing.T) {
+	mock := setupQueueStatusDB(t)
+	queueID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	wsID := "cccccccc-cccc-cccc-cccc-cccccccccccc"
+
+	respBody := []byte(`{"text":"delegation result"}`)
+	rows := sqlmock.NewRows([]string{
+		"id", "workspace_id", "status", "priority", "attempts",
+		"last_error", "enqueued_at", "dispatched_at", "completed_at", "expires_at",
+		"response_body",
+	}).AddRow(
+		queueID, wsID, "completed", 50, 1,
+		nil,
+		"2026-01-01T00:00:00Z",
+		"2026-01-01T00:01:00Z",
+		"2026-01-01T00:02:00Z",
+		nil,
+		respBody,
+	)
+	mock.ExpectQuery(`SELECT`).
+		WithArgs(queueID).
+		WillReturnRows(rows)
+
+	qs, err := QueueStatusByID(context.Background(), queueID)
+	if err != nil {
+		t.Fatalf("QueueStatusByID returned error: %v", err)
+	}
+	if qs.Status != "completed" {
+		t.Errorf("Status = %q, want completed", qs.Status)
+	}
+	if qs.ResponseBody == nil {
+		t.Fatal("ResponseBody should be set for completed status")
+	}
+	if string(qs.ResponseBody) != `{"text":"delegation result"}` {
+		t.Errorf("ResponseBody = %q, want %q", string(qs.ResponseBody), `{"text":"delegation result"}`)
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+// ── queueRowAuthFields ──────────────────────────────────────────────────────────
+
+func TestQueueRowAuthFields_Success(t *testing.T) {
+	mock := setupQueueStatusDB(t)
+	queueID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	callerID := "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"
+	wsID := "cccccccc-cccc-cccc-cccc-cccccccccccc"
+
+	rows := sqlmock.NewRows([]string{"caller_id", "workspace_id"}).
+		AddRow(callerID, wsID)
+	mock.ExpectQuery(`SELECT caller_id, workspace_id FROM a2a_queue WHERE id`).
+		WithArgs(queueID).
+		WillReturnRows(rows)
+
+	gotCaller, gotWs, err := queueRowAuthFields(context.Background(), queueID)
+	if err != nil {
+		t.Fatalf("queueRowAuthFields returned error: %v", err)
+	}
+	if gotCaller != callerID {
+		t.Errorf("callerID = %q, want %q", gotCaller, callerID)
+	}
+	if gotWs != wsID {
+		t.Errorf("workspaceID = %q, want %q", gotWs, wsID)
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestQueueRowAuthFields_NotFound(t *testing.T) {
+	mock := setupQueueStatusDB(t)
+	queueID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+
+	mock.ExpectQuery(`SELECT caller_id, workspace_id FROM a2a_queue WHERE id`).
+		WithArgs(queueID).
+		WillReturnError(sql.ErrNoRows)
+
+	_, _, err := queueRowAuthFields(context.Background(), queueID)
+	if err != sql.ErrNoRows {
+		t.Errorf("expected sql.ErrNoRows, got %v", err)
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestQueueRowAuthFields_DBError(t *testing.T) {
+	mock := setupQueueStatusDB(t)
+	queueID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+
+	mock.ExpectQuery(`SELECT caller_id, workspace_id FROM a2a_queue WHERE id`).
+		WithArgs(queueID).
+		WillReturnError(sql.ErrConnDone)
+
+	_, _, err := queueRowAuthFields(context.Background(), queueID)
+	if err == nil {
+		t.Error("expected error, got nil")
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}

workspace-server/internal/handlers/a2a_queue_test.go

@@ -516,3 +516,51 @@ func TestDrainQueueForWorkspace_ClaimGuarding_SecondDrainGetsEmpty(t *testing.T)
 		t.Errorf("unmet sqlmock expectations: %v", err)
 	}
 }
+
+// ── QueueDepth ──────────────────────────────────────────────────────────────────
+
+func TestQueueDepth_ReturnsCount(t *testing.T) {
+	mockDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
+	if err != nil {
+		t.Fatalf("failed to create sqlmock: %v", err)
+	}
+	prevDB := db.DB
+	db.DB = mockDB
+	t.Cleanup(func() { db.DB = prevDB; mockDB.Close() })
+
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	mock.ExpectQuery(`SELECT COUNT(*) FROM a2a_queue WHERE workspace_id = $1 AND status = 'queued'`).
+		WithArgs(wsID).
+		WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(42))
+
+	got := QueueDepth(context.Background(), wsID)
+	if got != 42 {
+		t.Errorf("QueueDepth returned %d, want 42", got)
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}
+
+func TestQueueDepth_ZeroWhenEmpty(t *testing.T) {
+	mockDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
+	if err != nil {
+		t.Fatalf("failed to create sqlmock: %v", err)
+	}
+	prevDB := db.DB
+	db.DB = mockDB
+	t.Cleanup(func() { db.DB = prevDB; mockDB.Close() })
+
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	mock.ExpectQuery(`SELECT COUNT(*) FROM a2a_queue WHERE workspace_id = $1 AND status = 'queued'`).
+		WithArgs(wsID).
+		WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(0))
+
+	got := QueueDepth(context.Background(), wsID)
+	if got != 0 {
+		t.Errorf("QueueDepth returned %d, want 0", got)
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet sqlmock expectations: %v", err)
+	}
+}

workspace-server/internal/handlers/channels_test.go

@@ -947,6 +947,73 @@ func TestVerifyDiscordSignature_WrongLengthPubKey(t *testing.T) {
 	}
 }
 
+// ==================== matchesChatID pure function ====================
+
+func TestMatchesChatID_ExactMatch(t *testing.T) {
+	cfg := map[string]interface{}{"chat_id": "123456"}
+	if !matchesChatID(cfg, "123456") {
+		t.Error("expected true for exact match")
+	}
+}
+
+func TestMatchesChatID_NoMatch(t *testing.T) {
+	cfg := map[string]interface{}{"chat_id": "123456"}
+	if matchesChatID(cfg, "654321") {
+		t.Error("expected false for non-matching chat ID")
+	}
+}
+
+func TestMatchesChatID_PrefixNoMatch(t *testing.T) {
+	// "123" is a prefix of "123456" but not an exact match.
+	cfg := map[string]interface{}{"chat_id": "123456"}
+	if matchesChatID(cfg, "123") {
+		t.Error("expected false for prefix of stored chat ID")
+	}
+}
+
+func TestMatchesChatID_CommaSeparatedMultiple(t *testing.T) {
+	cfg := map[string]interface{}{"chat_id": "111,222,333"}
+	for _, id := range []string{"111", "222", "333"} {
+		if !matchesChatID(cfg, id) {
+			t.Errorf("expected true for %q in comma-separated list", id)
+		}
+	}
+	if matchesChatID(cfg, "444") {
+		t.Error("expected false for ID not in list")
+	}
+}
+
+func TestMatchesChatID_WhitespaceTrimmed(t *testing.T) {
+	cfg := map[string]interface{}{"chat_id": "111, 222 , 333"}
+	if !matchesChatID(cfg, "222") {
+		t.Error("expected true for whitespace-trimmed match")
+	}
+	if matchesChatID(cfg, " 222") {
+		t.Error("expected false for whitespace in query (not trimmed from query)")
+	}
+}
+
+func TestMatchesChatID_EmptyChatID(t *testing.T) {
+	cfg := map[string]interface{}{"chat_id": ""}
+	if matchesChatID(cfg, "123456") {
+		t.Error("expected false for empty chat_id in config")
+	}
+}
+
+func TestMatchesChatID_MissingChatIDKey(t *testing.T) {
+	cfg := map[string]interface{}{}
+	if matchesChatID(cfg, "123456") {
+		t.Error("expected false when chat_id key is missing")
+	}
+}
+
+func TestMatchesChatID_NonStringChatID(t *testing.T) {
+	cfg := map[string]interface{}{"chat_id": 123456} // wrong type
+	if matchesChatID(cfg, "123456") {
+		t.Error("expected false when chat_id is not a string")
+	}
+}
+
 // TestChannelHandler_Webhook_Discord_NoKey_Returns401 verifies that a Discord
 // webhook request is rejected with 401 when no public key is configured in the
 // DB and DISCORD_APP_PUBLIC_KEY env var is not set.

workspace-server/internal/handlers/workspace_abilities_test.go

@@ -1,386 +0,0 @@
-package handlers
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/DATA-DOG/go-sqlmock"
-	"github.com/gin-gonic/gin"
-)
-
-// ---------- Validation ----------
-
-func TestPatchAbilities_InvalidWorkspaceID(t *testing.T) {
-	mock := setupTestDB(t)
-	// No DB calls expected — validation fails first.
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "not-a-uuid"}}
-	c.Request = httptest.NewRequest("PATCH", "/workspaces/not-a-uuid/abilities", bytes.NewBufferString(`{"broadcast_enabled":true}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	PatchAbilities(c)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400, got %d", w.Code)
-	}
-	var resp map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to unmarshal: %v", err)
-	}
-	if resp["error"] != "invalid workspace ID" {
-		t.Errorf("unexpected error: %v", resp["error"])
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unexpected DB calls: %v", err)
-	}
-}
-
-func TestPatchAbilities_NoFieldsProvided(t *testing.T) {
-	mock := setupTestDB(t)
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "00000000-0000-0000-0000-000000000001"}}
-	c.Request = httptest.NewRequest("PATCH", "/abilities", bytes.NewBufferString(`{}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	PatchAbilities(c)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400, got %d", w.Code)
-	}
-	var resp map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to unmarshal: %v", err)
-	}
-	if resp["error"] != "at least one ability field required" {
-		t.Errorf("unexpected error: %v", resp["error"])
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unexpected DB calls: %v", err)
-	}
-}
-
-func TestPatchAbilities_InvalidBody(t *testing.T) {
-	mock := setupTestDB(t)
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "00000000-0000-0000-0000-000000000001"}}
-	c.Request = httptest.NewRequest("PATCH", "/abilities", bytes.NewBufferString(`{invalid json}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	PatchAbilities(c)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400, got %d", w.Code)
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unexpected DB calls: %v", err)
-	}
-}
-
-// ---------- Workspace existence check ----------
-
-func TestPatchAbilities_WorkspaceNotFound(t *testing.T) {
-	mock := setupTestDB(t)
-	wsID := "00000000-0000-0000-0000-000000000001"
-
-	mock.ExpectQuery(`SELECT EXISTS\(SELECT 1 FROM workspaces WHERE id = \$1 AND status != 'removed'\)`).
-		WithArgs(wsID).
-		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(false))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: wsID}}
-	c.Request = httptest.NewRequest("PATCH", "/abilities", bytes.NewBufferString(`{"broadcast_enabled":true}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	PatchAbilities(c)
-
-	if w.Code != http.StatusNotFound {
-		t.Errorf("expected 404, got %d", w.Code)
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestPatchAbilities_ExistsCheckDBError(t *testing.T) {
-	mock := setupTestDB(t)
-	wsID := "00000000-0000-0000-0000-000000000001"
-
-	mock.ExpectQuery(`SELECT EXISTS\(SELECT 1 FROM workspaces WHERE id = \$1 AND status != 'removed'\)`).
-		WithArgs(wsID).
-		WillReturnError(errors.New("connection lost"))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: wsID}}
-	c.Request = httptest.NewRequest("PATCH", "/abilities", bytes.NewBufferString(`{"broadcast_enabled":true}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	PatchAbilities(c)
-
-	// DB error returns 404 (same as "not found").
-	if w.Code != http.StatusNotFound {
-		t.Errorf("expected 404, got %d", w.Code)
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-// ---------- BroadcastEnabled ----------
-
-func TestPatchAbilities_BroadcastEnabled_True(t *testing.T) {
-	mock := setupTestDB(t)
-	wsID := "00000000-0000-0000-0000-000000000001"
-
-	mock.ExpectQuery(`SELECT EXISTS\(SELECT 1 FROM workspaces WHERE id = \$1 AND status != 'removed'\)`).
-		WithArgs(wsID).
-		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
-
-	mock.ExpectExec(`UPDATE workspaces SET broadcast_enabled = \$2, updated_at = now\(\) WHERE id = \$1`).
-		WithArgs(wsID, true).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: wsID}}
-	c.Request = httptest.NewRequest("PATCH", "/abilities", bytes.NewBufferString(`{"broadcast_enabled":true}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	PatchAbilities(c)
-
-	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	var resp map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to unmarshal: %v", err)
-	}
-	if resp["status"] != "updated" {
-		t.Errorf("expected status 'updated', got %v", resp["status"])
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestPatchAbilities_BroadcastEnabled_False(t *testing.T) {
-	mock := setupTestDB(t)
-	wsID := "00000000-0000-0000-0000-000000000001"
-
-	mock.ExpectQuery(`SELECT EXISTS\(SELECT 1 FROM workspaces WHERE id = \$1 AND status != 'removed'\)`).
-		WithArgs(wsID).
-		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
-
-	mock.ExpectExec(`UPDATE workspaces SET broadcast_enabled = \$2, updated_at = now\(\) WHERE id = \$1`).
-		WithArgs(wsID, false).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: wsID}}
-	c.Request = httptest.NewRequest("PATCH", "/abilities", bytes.NewBufferString(`{"broadcast_enabled":false}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	PatchAbilities(c)
-
-	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestPatchAbilities_BroadcastEnabled_UpdateFails(t *testing.T) {
-	mock := setupTestDB(t)
-	wsID := "00000000-0000-0000-0000-000000000001"
-
-	mock.ExpectQuery(`SELECT EXISTS\(SELECT 1 FROM workspaces WHERE id = \$1 AND status != 'removed'\)`).
-		WithArgs(wsID).
-		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
-
-	mock.ExpectExec(`UPDATE workspaces SET broadcast_enabled = \$2, updated_at = now\(\) WHERE id = \$1`).
-		WithArgs(wsID, true).
-		WillReturnError(errors.New("update failed"))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: wsID}}
-	c.Request = httptest.NewRequest("PATCH", "/abilities", bytes.NewBufferString(`{"broadcast_enabled":true}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	PatchAbilities(c)
-
-	if w.Code != http.StatusInternalServerError {
-		t.Errorf("expected 500, got %d", w.Code)
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-// ---------- TalkToUserEnabled ----------
-
-func TestPatchAbilities_TalkToUserEnabled_True(t *testing.T) {
-	mock := setupTestDB(t)
-	wsID := "00000000-0000-0000-0000-000000000001"
-
-	mock.ExpectQuery(`SELECT EXISTS\(SELECT 1 FROM workspaces WHERE id = \$1 AND status != 'removed'\)`).
-		WithArgs(wsID).
-		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
-
-	mock.ExpectExec(`UPDATE workspaces SET talk_to_user_enabled = \$2, updated_at = now\(\) WHERE id = \$1`).
-		WithArgs(wsID, true).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: wsID}}
-	c.Request = httptest.NewRequest("PATCH", "/abilities", bytes.NewBufferString(`{"talk_to_user_enabled":true}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	PatchAbilities(c)
-
-	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestPatchAbilities_TalkToUserEnabled_False(t *testing.T) {
-	mock := setupTestDB(t)
-	wsID := "00000000-0000-0000-0000-000000000001"
-
-	mock.ExpectQuery(`SELECT EXISTS\(SELECT 1 FROM workspaces WHERE id = \$1 AND status != 'removed'\)`).
-		WithArgs(wsID).
-		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
-
-	mock.ExpectExec(`UPDATE workspaces SET talk_to_user_enabled = \$2, updated_at = now\(\) WHERE id = \$1`).
-		WithArgs(wsID, false).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: wsID}}
-	c.Request = httptest.NewRequest("PATCH", "/abilities", bytes.NewBufferString(`{"talk_to_user_enabled":false}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	PatchAbilities(c)
-
-	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestPatchAbilities_TalkToUserEnabled_UpdateFails(t *testing.T) {
-	mock := setupTestDB(t)
-	wsID := "00000000-0000-0000-0000-000000000001"
-
-	mock.ExpectQuery(`SELECT EXISTS\(SELECT 1 FROM workspaces WHERE id = \$1 AND status != 'removed'\)`).
-		WithArgs(wsID).
-		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
-
-	mock.ExpectExec(`UPDATE workspaces SET talk_to_user_enabled = \$2, updated_at = now\(\) WHERE id = \$1`).
-		WithArgs(wsID, false).
-		WillReturnError(errors.New("connection lost"))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: wsID}}
-	c.Request = httptest.NewRequest("PATCH", "/abilities", bytes.NewBufferString(`{"talk_to_user_enabled":false}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	PatchAbilities(c)
-
-	if w.Code != http.StatusInternalServerError {
-		t.Errorf("expected 500, got %d", w.Code)
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-// ---------- Both fields together ----------
-
-func TestPatchAbilities_BothFields(t *testing.T) {
-	mock := setupTestDB(t)
-	wsID := "00000000-0000-0000-0000-000000000001"
-
-	mock.ExpectQuery(`SELECT EXISTS\(SELECT 1 FROM workspaces WHERE id = \$1 AND status != 'removed'\)`).
-		WithArgs(wsID).
-		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
-
-	mock.ExpectExec(`UPDATE workspaces SET broadcast_enabled = \$2, updated_at = now\(\) WHERE id = \$1`).
-		WithArgs(wsID, true).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-
-	mock.ExpectExec(`UPDATE workspaces SET talk_to_user_enabled = \$2, updated_at = now\(\) WHERE id = \$1`).
-		WithArgs(wsID, false).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: wsID}}
-	c.Request = httptest.NewRequest("PATCH", "/abilities", bytes.NewBufferString(`{"broadcast_enabled":true,"talk_to_user_enabled":false}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	PatchAbilities(c)
-
-	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	var resp map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to unmarshal: %v", err)
-	}
-	if resp["status"] != "updated" {
-		t.Errorf("expected status 'updated', got %v", resp["status"])
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-// ---------- BroadcastEnabled with nil TalkToUserEnabled ----------
-
-func TestPatchAbilities_BroadcastOnly_OmitsTalkToUser(t *testing.T) {
-	mock := setupTestDB(t)
-	wsID := "00000000-0000-0000-0000-000000000001"
-
-	mock.ExpectQuery(`SELECT EXISTS\(SELECT 1 FROM workspaces WHERE id = \$1 AND status != 'removed'\)`).
-		WithArgs(wsID).
-		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
-
-	// Only broadcast_enabled update; talk_to_user_enabled must NOT be updated.
-	mock.ExpectExec(`UPDATE workspaces SET broadcast_enabled = \$2, updated_at = now\(\) WHERE id = \$1`).
-		WithArgs(wsID, true).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: wsID}}
-	c.Request = httptest.NewRequest("PATCH", "/abilities", bytes.NewBufferString(`{"broadcast_enabled":true}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	PatchAbilities(c)
-
-	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations — talk_to_user_enabled should not be updated: %v", err)
-	}
-}

workspace-server/internal/handlers/workspace_broadcast_test.go

@@ -1,442 +0,0 @@
-package handlers
-
-import (
-	"bytes"
-	"database/sql"
-	"encoding/json"
-	"errors"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/DATA-DOG/go-sqlmock"
-	"github.com/gin-gonic/gin"
-)
-
-// ---------- Validation ----------
-
-func TestBroadcast_InvalidWorkspaceID(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	// No DB calls expected — validation fails first.
-	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")
-
-	handler.Broadcast(c)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400, got %d", w.Code)
-	}
-	var resp map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to unmarshal: %v", err)
-	}
-	if resp["error"] != "invalid workspace ID" {
-		t.Errorf("unexpected error: %v", resp["error"])
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unexpected DB calls: %v", err)
-	}
-}
-
-func TestBroadcast_MissingMessage(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "00000000-0000-0000-0000-000000000001"}}
-	c.Request = httptest.NewRequest("POST", "/broadcast", bytes.NewBufferString(`{}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400, got %d", w.Code)
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unexpected DB calls: %v", err)
-	}
-}
-
-func TestBroadcast_EmptyMessage(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "00000000-0000-0000-0000-000000000001"}}
-	c.Request = httptest.NewRequest("POST", "/broadcast", bytes.NewBufferString(`{"message":""}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	// binding:"required" rejects empty string.
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400, got %d", w.Code)
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unexpected DB calls: %v", err)
-	}
-}
-
-// ---------- Sender lookup ----------
-
-func TestBroadcast_NotFound(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	senderID := "00000000-0000-0000-0000-000000000001"
-	mock.ExpectQuery(`SELECT name, broadcast_enabled FROM workspaces WHERE id = \$1 AND status != 'removed'`).
-		WithArgs(senderID).
-		WillReturnError(sql.ErrNoRows)
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: senderID}}
-	c.Request = httptest.NewRequest("POST", "/broadcast", bytes.NewBufferString(`{"message":"hello"}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	if w.Code != http.StatusNotFound {
-		t.Errorf("expected 404, got %d", w.Code)
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestBroadcast_Disabled(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	senderID := "00000000-0000-0000-0000-000000000001"
-	mock.ExpectQuery(`SELECT name, broadcast_enabled FROM workspaces WHERE id = \$1 AND status != 'removed'`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).AddRow("Disabled Workspace", false))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: senderID}}
-	c.Request = httptest.NewRequest("POST", "/broadcast", bytes.NewBufferString(`{"message":"hello"}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	if w.Code != http.StatusForbidden {
-		t.Errorf("expected 403, got %d", w.Code)
-	}
-	var resp map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to unmarshal: %v", err)
-	}
-	if resp["error"] != "broadcast_disabled" {
-		t.Errorf("expected error 'broadcast_disabled', got %v", resp["error"])
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-// ---------- Recipient collection ----------
-
-func TestBroadcast_EmptyRecipients_NoOtherWorkspaces(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	senderID := "00000000-0000-0000-0000-000000000001"
-
-	// Sender lookup succeeds.
-	mock.ExpectQuery(`SELECT name, broadcast_enabled FROM workspaces WHERE id = \$1 AND status != 'removed'`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).AddRow("Solo Workspace", true))
-
-	// No other workspaces.
-	mock.ExpectQuery(`SELECT id FROM workspaces WHERE status != 'removed' AND id != \$1`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"id"}))
-
-	// Only sender's own activity log.
-	mock.ExpectExec(`INSERT INTO activity_logs`).
-		WithArgs(senderID, sqlmock.AnyArg()).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: senderID}}
-	c.Request = httptest.NewRequest("POST", "/broadcast", bytes.NewBufferString(`{"message":"hello"}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	var resp map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to unmarshal: %v", err)
-	}
-	if resp["status"] != "sent" {
-		t.Errorf("expected status 'sent', got %v", resp["status"])
-	}
-	if resp["delivered"].(float64) != 0 {
-		t.Errorf("expected delivered=0, got %v", resp["delivered"])
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestBroadcast_Success_SingleRecipient(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	senderID := "00000000-0000-0000-0000-000000000001"
-	recipientID := "00000000-0000-0000-0000-000000000002"
-
-	mock.ExpectQuery(`SELECT name, broadcast_enabled FROM workspaces WHERE id = \$1 AND status != 'removed'`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).AddRow("Sender Workspace", true))
-
-	mock.ExpectQuery(`SELECT id FROM workspaces WHERE status != 'removed' AND id != \$1`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(recipientID))
-
-	// Recipient activity log.
-	mock.ExpectExec(`INSERT INTO activity_logs`).
-		WithArgs(recipientID, senderID, sqlmock.AnyArg()).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-	// Sender activity log.
-	mock.ExpectExec(`INSERT INTO activity_logs`).
-		WithArgs(senderID, sqlmock.AnyArg()).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: senderID}}
-	c.Request = httptest.NewRequest("POST", "/broadcast", bytes.NewBufferString(`{"message":"hello everyone"}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	var resp map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to unmarshal: %v", err)
-	}
-	if resp["delivered"].(float64) != 1 {
-		t.Errorf("expected delivered=1, got %v", resp["delivered"])
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestBroadcast_Success_MultipleRecipients(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	senderID := "00000000-0000-0000-0000-000000000001"
-	recipient1 := "00000000-0000-0000-0000-000000000002"
-	recipient2 := "00000000-0000-0000-0000-000000000003"
-
-	mock.ExpectQuery(`SELECT name, broadcast_enabled FROM workspaces WHERE id = \$1 AND status != 'removed'`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).AddRow("Sender", true))
-
-	mock.ExpectQuery(`SELECT id FROM workspaces WHERE status != 'removed' AND id != \$1`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(recipient1).AddRow(recipient2))
-
-	mock.ExpectExec(`INSERT INTO activity_logs`).
-		WithArgs(recipient1, senderID, sqlmock.AnyArg()).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-	mock.ExpectExec(`INSERT INTO activity_logs`).
-		WithArgs(recipient2, senderID, sqlmock.AnyArg()).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-	mock.ExpectExec(`INSERT INTO activity_logs`).
-		WithArgs(senderID, sqlmock.AnyArg()).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: senderID}}
-	c.Request = httptest.NewRequest("POST", "/broadcast", bytes.NewBufferString(`{"message":"hello all"}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	var resp map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to unmarshal: %v", err)
-	}
-	if resp["delivered"].(float64) != 2 {
-		t.Errorf("expected delivered=2, got %v", resp["delivered"])
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-// ---------- Error handling ----------
-
-func TestBroadcast_RecipientQueryError(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	senderID := "00000000-0000-0000-0000-000000000001"
-
-	mock.ExpectQuery(`SELECT name, broadcast_enabled FROM workspaces WHERE id = \$1 AND status != 'removed'`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).AddRow("Sender", true))
-
-	mock.ExpectQuery(`SELECT id FROM workspaces WHERE status != 'removed' AND id != \$1`).
-		WithArgs(senderID).
-		WillReturnError(errors.New("connection lost"))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: senderID}}
-	c.Request = httptest.NewRequest("POST", "/broadcast", bytes.NewBufferString(`{"message":"hello"}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	// Returns 500 on recipient query failure (sender activity log not written either).
-	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_RecipientRowsError(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	senderID := "00000000-0000-0000-0000-000000000001"
-
-	mock.ExpectQuery(`SELECT name, broadcast_enabled FROM workspaces WHERE id = \$1 AND status != 'removed'`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).AddRow("Sender", true))
-
-	// Return rows with an error on rows.Err().
-	rows := sqlmock.NewRows([]string{"id"}).AddRow("r1").RowError(0, errors.New("scan error"))
-	mock.ExpectQuery(`SELECT id FROM workspaces WHERE status != 'removed' AND id != \$1`).
-		WithArgs(senderID).
-		WillReturnRows(rows)
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: senderID}}
-	c.Request = httptest.NewRequest("POST", "/broadcast", bytes.NewBufferString(`{"message":"hello"}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.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_ActivityLogInsertFails(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	senderID := "00000000-0000-0000-0000-000000000001"
-	recipientID := "00000000-0000-0000-0000-000000000002"
-
-	mock.ExpectQuery(`SELECT name, broadcast_enabled FROM workspaces WHERE id = \$1 AND status != 'removed'`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).AddRow("Sender", true))
-
-	mock.ExpectQuery(`SELECT id FROM workspaces WHERE status != 'removed' AND id != \$1`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(recipientID))
-
-	// Recipient activity log fails — handler logs and continues.
-	mock.ExpectExec(`INSERT INTO activity_logs`).
-		WithArgs(recipientID, senderID, sqlmock.AnyArg()).
-		WillReturnError(errors.New("insert failed"))
-
-	// Sender activity log succeeds.
-	mock.ExpectExec(`INSERT INTO activity_logs`).
-		WithArgs(senderID, sqlmock.AnyArg()).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: senderID}}
-	c.Request = httptest.NewRequest("POST", "/broadcast", bytes.NewBufferString(`{"message":"hello"}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	// Still returns 200 — recipient failures are logged and skipped.
-	if w.Code != http.StatusOK {
-		t.Errorf("expected 200 (fail-open), got %d: %s", w.Code, w.Body.String())
-	}
-	var resp map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to unmarshal: %v", err)
-	}
-	// delivered=0 because the only recipient's insert failed.
-	if resp["delivered"].(float64) != 0 {
-		t.Errorf("expected delivered=0, got %v", resp["delivered"])
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-// ---------- broadcastTruncate ----------
-
-func TestBroadcast_Truncate(t *testing.T) {
-	tests := []struct {
-		name string
-		s    string
-		max  int
-		want string
-	}{
-		{"empty string", "", 10, ""},
-		{"under limit", "hello", 10, "hello"},
-		{"exact limit", "hello", 5, "hello"},
-		{"over limit", "hello world", 5, "hello…"},
-		{"unicode over limit", "こんにちは世界", 5, "こんにちは…"},
-		{"exactly at limit", "abcde", 5, "abcde"},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			got := broadcastTruncate(tc.s, tc.max)
-			if got != tc.want {
-				t.Errorf("broadcastTruncate(%q, %d) = %q; want %q", tc.s, tc.max, got, tc.want)
-			}
-		})
-	}
-}