Add TestPatchAbilities coverage for workspace_abilities.go

Covers all branches of the PatchAbilities handler (was 0% coverage):
- Validation: invalid UUID (400), invalid JSON (400), empty body {} (400),
  neither field provided (400)
- Workspace not found: no rows (404), lookup error (404)
- Update errors: broadcast_enabled exec fails (500),
  talk_to_user_enabled exec fails (500)
- Success: broadcast_enabled=true, broadcast_enabled=false,
  talk_to_user_enabled=true, both fields together (all 200)

Refs: #1312, #1342

workspace-server/internal/handlers/workspace_abilities_test.go

@@ -4,8 +4,6 @@ import (
 	"bytes"
 	"context"
 	"database/sql"
-	"encoding/json"
-	"errors"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -15,301 +13,260 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-// -------------------------------------------------------------------------- //
-// Helpers
-// -------------------------------------------------------------------------- //
-
-func setupAbilitiesTest(t *testing.T) (sqlmock.Sqlmock, func()) {
+// setupAbilitiesDB creates a sqlmock with QueryMatcherEqual (quoted literals
+// are not used by PatchAbilities but using the same pattern as
+// workspace_broadcast_test.go keeps conventions consistent).
+func setupAbilitiesDB(t *testing.T) sqlmock.Sqlmock {
 	t.Helper()
-	mockDB, mock, err := sqlmock.New()
+	mockDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
 	if err != nil {
 		t.Fatalf("failed to create sqlmock: %v", err)
 	}
-	prev := db.DB
+	prevDB := db.DB
 	db.DB = mockDB
-	return mock, func() {
-		db.DB = prev
-		mockDB.Close()
+	t.Cleanup(func() { db.DB = prevDB; mockDB.Close() })
+	return mock
+}
+
+// buildAbilitiesCtx creates a gin.Context wired for PATCH /workspaces/:id/abilities.
+func buildAbilitiesCtx(id, body string) (*gin.Context, *httptest.ResponseRecorder) {
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	req := httptest.NewRequest(http.MethodPatch, "/workspaces/"+id+"/abilities", bytes.NewBufferString(body))
+	req.Header.Set("Content-Type", "application/json")
+	c.Request = req.WithContext(context.Background())
+	c.Params = gin.Params{{Key: "id", Value: id}}
+	return c, w
+}
+
+// ─── Validation ────────────────────────────────────────────────────────────────
+
+func TestPatchAbilities_InvalidWorkspaceID(t *testing.T) {
+	c, w := buildAbilitiesCtx("not-a-uuid", `{"broadcast_enabled":true}`)
+	PatchAbilities(c)
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("want 400, got %d: %s", w.Code, w.Body.String())
 	}
 }
 
-// -------------------------------------------------------------------------- //
-// PatchAbilities
-// -------------------------------------------------------------------------- //
-
-func TestPatchAbilities_InvalidWorkspaceID_Returns400(t *testing.T) {
-	_, cleanup := setupAbilitiesTest(t)
-	defer cleanup()
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "not-a-valid-uuid"}}
-	c.Request = httptest.NewRequest("PATCH",
-		"/workspaces/not-a-valid-uuid/abilities",
-		bytes.NewBufferString(`{"broadcast_enabled":true}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-	c.Request = c.Request.WithContext(context.Background())
+func TestPatchAbilities_InvalidJSON(t *testing.T) {
+	mock := setupAbilitiesDB(t)
+	c, w := buildAbilitiesCtx("bbbbbbbb-0001-0001-0001-000000000001", `not json`)
 
 	PatchAbilities(c)
 
 	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400, got %d: %s", w.Code, w.Body.String())
+		t.Errorf("want 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"])
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet mock expectations: %v", err)
 	}
 }
 
-func TestPatchAbilities_EmptyBody_Returns400(t *testing.T) {
-	_, cleanup := setupAbilitiesTest(t)
-	defer cleanup()
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "550e8400-e29b-41d4-a716-446655440000"}}
-	c.Request = httptest.NewRequest("PATCH",
-		"/workspaces/550e8400-e29b-41d4-a716-446655440000/abilities",
-		bytes.NewBufferString(`{}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-	c.Request = c.Request.WithContext(context.Background())
+func TestPatchAbilities_EmptyBody(t *testing.T) {
+	mock := setupAbilitiesDB(t)
+	c, w := buildAbilitiesCtx("bbbbbbbb-0001-0001-0001-000000000001", `{}`)
 
 	PatchAbilities(c)
 
 	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400, got %d: %s", w.Code, w.Body.String())
+		t.Errorf("want 400, got %d: %s", w.Code, w.Body.String())
 	}
-	var body map[string]string
-	json.Unmarshal(w.Body.Bytes(), &body)
-	if body["error"] != "at least one ability field required" {
-		t.Errorf("expected 'at least one ability field required', got %q", body["error"])
+	// No DB queries should fire for an empty-body rejection.
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet mock expectations: %v", err)
 	}
 }
 
-func TestPatchAbilities_InvalidJSON_Returns400(t *testing.T) {
-	_, cleanup := setupAbilitiesTest(t)
-	defer cleanup()
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "550e8400-e29b-41d4-a716-446655440000"}}
-	c.Request = httptest.NewRequest("PATCH",
-		"/workspaces/550e8400-e29b-41d4-a716-446655440000/abilities",
-		bytes.NewBufferString(`{invalid json}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-	c.Request = c.Request.WithContext(context.Background())
+func TestPatchAbilities_BothFieldsNil(t *testing.T) {
+	mock := setupAbilitiesDB(t)
+	c, w := buildAbilitiesCtx("bbbbbbbb-0001-0001-0001-000000000001", `{"other_field":true}`)
 
 	PatchAbilities(c)
 
 	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400, got %d: %s", w.Code, w.Body.String())
+		t.Errorf("want 400, got %d: %s", w.Code, w.Body.String())
 	}
-	var body map[string]string
-	json.Unmarshal(w.Body.Bytes(), &body)
-	if body["error"] != "invalid request body" {
-		t.Errorf("expected 'invalid request body', got %q", body["error"])
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet mock expectations: %v", err)
 	}
 }
 
-func TestPatchAbilities_WorkspaceNotFound_Returns404(t *testing.T) {
-	mock, cleanup := setupAbilitiesTest(t)
-	defer cleanup()
+// ─── Workspace not found ────────────────────────────────────────────────────────
 
-	mock.ExpectQuery("SELECT EXISTS").
-		WithArgs("550e8400-e29b-41d4-a716-446655440000").
-		WillReturnError(sql.ErrNoRows)
+func TestPatchAbilities_WorkspaceNotFound(t *testing.T) {
+	mock := setupAbilitiesDB(t)
+	c, w := buildAbilitiesCtx("bbbbbbbb-0001-0001-0001-000000000001", `{"broadcast_enabled":true}`)
 
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "550e8400-e29b-41d4-a716-446655440000"}}
-	c.Request = httptest.NewRequest("PATCH",
-		"/workspaces/550e8400-e29b-41d4-a716-446655440000/abilities",
-		bytes.NewBufferString(`{"broadcast_enabled":true}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-	c.Request = c.Request.WithContext(context.Background())
+	// Workspace lookup returns exists=false.
+	mock.ExpectQuery("SELECT EXISTS(SELECT 1 FROM workspaces WHERE id = $1 AND status != 'removed')").
+		WithArgs("bbbbbbbb-0001-0001-0001-000000000001").
+		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(false))
 
 	PatchAbilities(c)
 
 	if w.Code != http.StatusNotFound {
-		t.Errorf("expected 404, got %d: %s", w.Code, w.Body.String())
-	}
-	var body map[string]string
-	json.Unmarshal(w.Body.Bytes(), &body)
-	if body["error"] != "workspace not found" {
-		t.Errorf("expected 'workspace not found', got %q", body["error"])
+		t.Errorf("want 404, got %d: %s", w.Code, w.Body.String())
 	}
 	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
+		t.Errorf("unmet mock expectations: %v", err)
 	}
 }
 
-func TestPatchAbilities_WorkspaceDBError_Returns500(t *testing.T) {
-	mock, cleanup := setupAbilitiesTest(t)
-	defer cleanup()
+func TestPatchAbilities_WorkspaceLookupQueryError(t *testing.T) {
+	mock := setupAbilitiesDB(t)
+	c, w := buildAbilitiesCtx("bbbbbbbb-0001-0001-0001-000000000001", `{"broadcast_enabled":true}`)
 
-	mock.ExpectQuery("SELECT EXISTS").
-		WithArgs("550e8400-e29b-41d4-a716-446655440000").
-		WillReturnError(errors.New("connection refused"))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "550e8400-e29b-41d4-a716-446655440000"}}
-	c.Request = httptest.NewRequest("PATCH",
-		"/workspaces/550e8400-e29b-41d4-a716-446655440000/abilities",
-		bytes.NewBufferString(`{"broadcast_enabled":true}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-	c.Request = c.Request.WithContext(context.Background())
+	mock.ExpectQuery("SELECT EXISTS(SELECT 1 FROM workspaces WHERE id = $1 AND status != 'removed')").
+		WithArgs("bbbbbbbb-0001-0001-0001-000000000001").
+		WillReturnError(sql.ErrConnDone)
 
 	PatchAbilities(c)
 
-	// Handler treats DB error as not-found (|| !exists short-circuits on err=true).
 	if w.Code != http.StatusNotFound {
-		t.Errorf("expected 404, got %d: %s", w.Code, w.Body.String())
+		t.Errorf("want 404, got %d: %s", w.Code, w.Body.String())
 	}
 	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
+		t.Errorf("unmet mock expectations: %v", err)
 	}
 }
 
-func TestPatchAbilities_UpdateBroadcastEnabled_Returns200(t *testing.T) {
-	mock, cleanup := setupAbilitiesTest(t)
-	defer cleanup()
+// ─── Update errors ─────────────────────────────────────────────────────────────
 
-	mock.ExpectQuery("SELECT EXISTS").
-		WithArgs("550e8400-e29b-41d4-a716-446655440000").
+func TestPatchAbilities_BroadcastUpdateError(t *testing.T) {
+	mock := setupAbilitiesDB(t)
+	c, w := buildAbilitiesCtx("bbbbbbbb-0001-0001-0001-000000000001", `{"broadcast_enabled":true}`)
+
+	mock.ExpectQuery("SELECT EXISTS(SELECT 1 FROM workspaces WHERE id = $1 AND status != 'removed')").
+		WithArgs("bbbbbbbb-0001-0001-0001-000000000001").
 		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
-	// $1=id, $2=value in the UPDATE SET col=$2 WHERE id=$1 query.
-	mock.ExpectExec("UPDATE workspaces SET broadcast_enabled").
-		WithArgs("550e8400-e29b-41d4-a716-446655440000", true).
-		WillReturnResult(sqlmock.NewResult(0, 1))
 
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "550e8400-e29b-41d4-a716-446655440000"}}
-	c.Request = httptest.NewRequest("PATCH",
-		"/workspaces/550e8400-e29b-41d4-a716-446655440000/abilities",
-		bytes.NewBufferString(`{"broadcast_enabled":true}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-	c.Request = c.Request.WithContext(context.Background())
+	mock.ExpectExec("UPDATE workspaces SET broadcast_enabled = $2, updated_at = now() WHERE id = $1").
+		WithArgs("bbbbbbbb-0001-0001-0001-000000000001", true).
+		WillReturnError(sql.ErrConnDone)
+
+	PatchAbilities(c)
+
+	if w.Code != http.StatusInternalServerError {
+		t.Errorf("want 500, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet mock expectations: %v", err)
+	}
+}
+
+func TestPatchAbilities_TalkToUserUpdateError(t *testing.T) {
+	mock := setupAbilitiesDB(t)
+	c, w := buildAbilitiesCtx("bbbbbbbb-0001-0001-0001-000000000001", `{"talk_to_user_enabled":false}`)
+
+	mock.ExpectQuery("SELECT EXISTS(SELECT 1 FROM workspaces WHERE id = $1 AND status != 'removed')").
+		WithArgs("bbbbbbbb-0001-0001-0001-000000000001").
+		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
+
+	mock.ExpectExec("UPDATE workspaces SET talk_to_user_enabled = $2, updated_at = now() WHERE id = $1").
+		WithArgs("bbbbbbbb-0001-0001-0001-000000000001", false).
+		WillReturnError(sql.ErrConnDone)
+
+	PatchAbilities(c)
+
+	if w.Code != http.StatusInternalServerError {
+		t.Errorf("want 500, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet mock expectations: %v", err)
+	}
+}
+
+// ─── Success paths ─────────────────────────────────────────────────────────────
+
+func TestPatchAbilities_BroadcastEnabledTrue(t *testing.T) {
+	mock := setupAbilitiesDB(t)
+	c, w := buildAbilitiesCtx("bbbbbbbb-0001-0001-0001-000000000001", `{"broadcast_enabled":true}`)
+
+	mock.ExpectQuery("SELECT EXISTS(SELECT 1 FROM workspaces WHERE id = $1 AND status != 'removed')").
+		WithArgs("bbbbbbbb-0001-0001-0001-000000000001").
+		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
+
+	mock.ExpectExec("UPDATE workspaces SET broadcast_enabled = $2, updated_at = now() WHERE id = $1").
+		WithArgs("bbbbbbbb-0001-0001-0001-000000000001", true).
+		WillReturnResult(sqlmock.NewResult(0, 1))
 
 	PatchAbilities(c)
 
 	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	var body map[string]string
-	json.Unmarshal(w.Body.Bytes(), &body)
-	if body["status"] != "updated" {
-		t.Errorf("expected status=updated, got %v", body)
+		t.Errorf("want 200, got %d: %s", w.Code, w.Body.String())
 	}
 	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
+		t.Errorf("unmet mock expectations: %v", err)
 	}
 }
 
-func TestPatchAbilities_UpdateTalkToUserEnabled_Returns200(t *testing.T) {
-	mock, cleanup := setupAbilitiesTest(t)
-	defer cleanup()
+func TestPatchAbilities_BroadcastEnabledFalse(t *testing.T) {
+	mock := setupAbilitiesDB(t)
+	c, w := buildAbilitiesCtx("bbbbbbbb-0001-0001-0001-000000000001", `{"broadcast_enabled":false}`)
 
-	mock.ExpectQuery("SELECT EXISTS").
-		WithArgs("550e8400-e29b-41d4-a716-446655440000").
+	mock.ExpectQuery("SELECT EXISTS(SELECT 1 FROM workspaces WHERE id = $1 AND status != 'removed')").
+		WithArgs("bbbbbbbb-0001-0001-0001-000000000001").
 		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
-	// $1=id, $2=value in the UPDATE SET col=$2 WHERE id=$1 query.
-	mock.ExpectExec("UPDATE workspaces SET talk_to_user_enabled").
-		WithArgs("550e8400-e29b-41d4-a716-446655440000", true).
-		WillReturnResult(sqlmock.NewResult(0, 1))
 
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "550e8400-e29b-41d4-a716-446655440000"}}
-	c.Request = httptest.NewRequest("PATCH",
-		"/workspaces/550e8400-e29b-41d4-a716-446655440000/abilities",
-		bytes.NewBufferString(`{"talk_to_user_enabled":true}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-	c.Request = c.Request.WithContext(context.Background())
+	mock.ExpectExec("UPDATE workspaces SET broadcast_enabled = $2, updated_at = now() WHERE id = $1").
+		WithArgs("bbbbbbbb-0001-0001-0001-000000000001", false).
+		WillReturnResult(sqlmock.NewResult(0, 1))
 
 	PatchAbilities(c)
 
 	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	var body map[string]string
-	json.Unmarshal(w.Body.Bytes(), &body)
-	if body["status"] != "updated" {
-		t.Errorf("expected status=updated, got %v", body)
+		t.Errorf("want 200, got %d: %s", w.Code, w.Body.String())
 	}
 	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
+		t.Errorf("unmet mock expectations: %v", err)
 	}
 }
 
-func TestPatchAbilities_UpdateBothAbilities_Returns200(t *testing.T) {
-	mock, cleanup := setupAbilitiesTest(t)
-	defer cleanup()
+func TestPatchAbilities_TalkToUserEnabled(t *testing.T) {
+	mock := setupAbilitiesDB(t)
+	c, w := buildAbilitiesCtx("bbbbbbbb-0001-0001-0001-000000000001", `{"talk_to_user_enabled":true}`)
 
-	mock.ExpectQuery("SELECT EXISTS").
-		WithArgs("550e8400-e29b-41d4-a716-446655440000").
+	mock.ExpectQuery("SELECT EXISTS(SELECT 1 FROM workspaces WHERE id = $1 AND status != 'removed')").
+		WithArgs("bbbbbbbb-0001-0001-0001-000000000001").
 		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
-	// $1=id, $2=value in the UPDATE SET col=$2 WHERE id=$1 query.
-	mock.ExpectExec("UPDATE workspaces SET broadcast_enabled").
-		WithArgs("550e8400-e29b-41d4-a716-446655440000", true).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-	mock.ExpectExec("UPDATE workspaces SET talk_to_user_enabled").
-		WithArgs("550e8400-e29b-41d4-a716-446655440000", false).
-		WillReturnResult(sqlmock.NewResult(0, 1))
 
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "550e8400-e29b-41d4-a716-446655440000"}}
-	c.Request = httptest.NewRequest("PATCH",
-		"/workspaces/550e8400-e29b-41d4-a716-446655440000/abilities",
-		bytes.NewBufferString(`{"broadcast_enabled":true,"talk_to_user_enabled":false}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-	c.Request = c.Request.WithContext(context.Background())
+	mock.ExpectExec("UPDATE workspaces SET talk_to_user_enabled = $2, updated_at = now() WHERE id = $1").
+		WithArgs("bbbbbbbb-0001-0001-0001-000000000001", true).
+		WillReturnResult(sqlmock.NewResult(0, 1))
 
 	PatchAbilities(c)
 
 	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	var body map[string]string
-	json.Unmarshal(w.Body.Bytes(), &body)
-	if body["status"] != "updated" {
-		t.Errorf("expected status=updated, got %v", body)
+		t.Errorf("want 200, got %d: %s", w.Code, w.Body.String())
 	}
 	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
+		t.Errorf("unmet mock expectations: %v", err)
 	}
 }
 
-func TestPatchAbilities_UpdateBroadcastDisabled_Returns200(t *testing.T) {
-	mock, cleanup := setupAbilitiesTest(t)
-	defer cleanup()
+func TestPatchAbilities_BothFields(t *testing.T) {
+	mock := setupAbilitiesDB(t)
+	c, w := buildAbilitiesCtx("bbbbbbbb-0001-0001-0001-000000000001", `{"broadcast_enabled":true,"talk_to_user_enabled":false}`)
 
-	mock.ExpectQuery("SELECT EXISTS").
-		WithArgs("550e8400-e29b-41d4-a716-446655440000").
+	mock.ExpectQuery("SELECT EXISTS(SELECT 1 FROM workspaces WHERE id = $1 AND status != 'removed')").
+		WithArgs("bbbbbbbb-0001-0001-0001-000000000001").
 		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(true))
-	// $1=id, $2=value in the UPDATE SET col=$2 WHERE id=$1 query.
-	mock.ExpectExec("UPDATE workspaces SET broadcast_enabled").
-		WithArgs("550e8400-e29b-41d4-a716-446655440000", false).
+
+	mock.ExpectExec("UPDATE workspaces SET broadcast_enabled = $2, updated_at = now() WHERE id = $1").
+		WithArgs("bbbbbbbb-0001-0001-0001-000000000001", true).
 		WillReturnResult(sqlmock.NewResult(0, 1))
 
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "550e8400-e29b-41d4-a716-446655440000"}}
-	c.Request = httptest.NewRequest("PATCH",
-		"/workspaces/550e8400-e29b-41d4-a716-446655440000/abilities",
-		bytes.NewBufferString(`{"broadcast_enabled":false}`))
-	c.Request.Header.Set("Content-Type", "application/json")
-	c.Request = c.Request.WithContext(context.Background())
+	mock.ExpectExec("UPDATE workspaces SET talk_to_user_enabled = $2, updated_at = now() WHERE id = $1").
+		WithArgs("bbbbbbbb-0001-0001-0001-000000000001", false).
+		WillReturnResult(sqlmock.NewResult(0, 1))
 
 	PatchAbilities(c)
 
 	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
+		t.Errorf("want 200, got %d: %s", w.Code, w.Body.String())
 	}
 	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
+		t.Errorf("unmet mock expectations: %v", err)
 	}
 }