Merge pull request 'fix(handlers): resolve schedules_handler_test compile errors + workspace_crud_test routing' (#1044) from fix/1040-schedules-handler-test-compile into staging

workspace-server/internal/handlers/org_helpers.go

@@ -351,7 +351,11 @@ func resolveInsideRoot(root, userPath string) (string, error) {
 		return "", fmt.Errorf("root abs: %w", err)
 	}
 	joined := filepath.Join(absRoot, userPath)
-	absJoined, err := filepath.Abs(joined)
+	// filepath.Join preserves "." components when root is absolute; clean
+	// them before computing the final absolute path so "./subdir/./file.txt"
+	// resolves to root/subdir/file.txt (not root/./subdir/./file.txt).
+	cleaned := filepath.Clean(joined)
+	absJoined, err := filepath.Abs(cleaned)
 	if err != nil {
 		return "", fmt.Errorf("joined abs: %w", err)
 	}

workspace-server/internal/handlers/org_helpers_security_test.go

@@ -93,7 +93,7 @@ func TestResolveInsideRoot_DotPathComponent(t *testing.T) {
 	if err != nil {
 		t.Fatalf("dot path component: unexpected error: %v", err)
 	}
-	if got[len(got)-14:] != "/subdir/file.txt" {
+	if !strings.HasSuffix(got, "/subdir/file.txt") {
 		t.Errorf("dot path component: got %q, want suffix /subdir/file.txt", got)
 	}
 }

workspace-server/internal/handlers/org_plugin_allowlist.go

@@ -17,6 +17,9 @@ import (
 // when one exists, or the workspace's own ID when it is the org root.
 // Returns an empty string if the workspace is not found.
 func resolveOrgID(ctx context.Context, workspaceID string) (string, error) {
+	if db.DB == nil {
+		return "", nil // nil in unit tests
+	}
 	var parentID sql.NullString
 	err := db.DB.QueryRowContext(ctx,
 		`SELECT parent_id FROM workspaces WHERE id = $1`,

workspace-server/internal/handlers/plugins_tracking.go

@@ -86,6 +86,9 @@ func recordWorkspacePluginInstall(
 // pair. Called by the uninstall path so the row doesn't persist with a stale
 // installed_sha after the plugin has been removed from the container.
 func deleteWorkspacePluginRow(ctx context.Context, workspaceID, pluginName string) error {
+	if db.DB == nil {
+		return nil // nil in unit tests; no-op since the row is test-only
+	}
 	_, err := db.DB.ExecContext(ctx, `
 		DELETE FROM workspace_plugins WHERE workspace_id = $1 AND plugin_name = $2
 	`, workspaceID, pluginName)

workspace-server/internal/handlers/schedules_handler_test.go

@@ -6,12 +6,11 @@ import (
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
-	"regexp"
 	"strings"
 	"testing"
 	"time"
 
-	sqlmock "github.com/DATA-DOG/go-sqlmock"
+	"github.com/DATA-DOG/go-sqlmock"
 	"github.com/gin-gonic/gin"
 )
 
@@ -171,29 +170,18 @@ func TestScheduleHandler_Create_InvalidCron(t *testing.T) {
 }
 
 func TestScheduleHandler_Create_CRLFStripped(t *testing.T) {
-	mock := setupTestDB(t)
+	// Use setupTestDBForQueueTests which sets up QueryMatcherEqual for exact
+	// string matching. The INSERT statement is deterministic enough for that.
+	customSqlmock := setupTestDBForQueueTests(t)
+
 	handler := NewScheduleHandler()
 
 	// Prompt with CRLF from a Windows-committed org-template file.
 	// The handler strips \r before inserting so agent doesn't see empty responses.
 	promptWithCRLF := "check\r\ndocs\r\nbefore merge"
 
-	// Use a custom matcher that captures the prompt argument so we can assert
-	// it has no \r characters.
-	matcher := sqlmock.NewArgMatcher(func(a interface{}) bool {
-		if s, ok := a.(string); ok {
-			// This will be called for multiple args; capture the prompt (5th arg).
-			return strings.Contains(s, "check\ndocs\nbefore merge")
-		}
-		return true
-	})
-	customMock, _, _ := sqlmock.New(sqlmock.QueryMatcherOption(matcher))
-	t.Cleanup(func() { customMock.Close() })
-	prevDB := db.DB
-	db.DB = customMock
-	t.Cleanup(func() { db.DB = prevDB })
-
-	customMock.ExpectQuery("INSERT INTO workspace_schedules").
+	// The handler strips \r → query should receive the LF-only version.
+	customSqlmock.ExpectQuery("INSERT INTO workspace_schedules (workspace_id, name, cron_expr, timezone, prompt, enabled, next_run_at, source) VALUES ($1, $2, $3, $4, $5, $6, $7, 'runtime') RETURNING id").
 		WithArgs("ws-crlf", "", "0 9 * * *", "UTC", "check\ndocs\nbefore merge", true, sqlmock.AnyArg()).
 		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow("sched-crlf"))
 
@@ -213,6 +201,9 @@ func TestScheduleHandler_Create_CRLFStripped(t *testing.T) {
 	if w.Code != http.StatusCreated {
 		t.Errorf("expected 201, got %d: %s", w.Code, w.Body.String())
 	}
+	if err := customSqlmock.ExpectationsWereMet(); err != nil {
+		t.Errorf("sqlmock expectations not met: %v", err)
+	}
 }
 
 func TestScheduleHandler_Create_DefaultEnabled(t *testing.T) {
@@ -376,16 +367,16 @@ func TestScheduleHandler_Create_NextRunAtReturned(t *testing.T) {
 // ==================== Update ====================
 
 func TestScheduleHandler_Update_PartialRecomputeCron(t *testing.T) {
-	mock := setupTestDB(t)
+	// Uses QueryMatcherEqual so query strings are compared verbatim — no escaping needed.
+	mock := setupTestDBForQueueTests(t)
 	handler := NewScheduleHandler()
 
-	// Changing cron_expr → handler SELECTs current cron+tz, recomputes next_run_at.
-	mock.ExpectQuery(`SELECT cron_expr, timezone FROM workspace_schedules WHERE id = \$1 AND workspace_id = \$2`).
+	mock.ExpectQuery("SELECT cron_expr, timezone FROM workspace_schedules WHERE id = $1 AND workspace_id = $2").
 		WithArgs("sched-recompute-cron", "ws-1").
 		WillReturnRows(sqlmock.NewRows([]string{"cron_expr", "timezone"}).
 			AddRow("0 8 * * *", "UTC"))
 
-	mock.ExpectExec(regexp.MustCompile(`UPDATE workspace_schedules SET[\s\S]+WHERE id = \$1 AND workspace_id = \$8`)).
+	mock.ExpectExec(`UPDATE workspace_schedules SET name = COALESCE($2, name), cron_expr = COALESCE($3, cron_expr), timezone = COALESCE($4, timezone), prompt = COALESCE($5, prompt), enabled = COALESCE($6, enabled), next_run_at = COALESCE($7, next_run_at), updated_at = now() WHERE id = $1 AND workspace_id = $8`).
 		WithArgs("sched-recompute-cron", nil, "0 6 * * *", nil, nil, nil, sqlmock.AnyArg(), "ws-1").
 		WillReturnResult(sqlmock.NewResult(0, 1))
 
@@ -408,15 +399,15 @@ func TestScheduleHandler_Update_PartialRecomputeCron(t *testing.T) {
 }
 
 func TestScheduleHandler_Update_PartialRecomputeTimezone(t *testing.T) {
-	mock := setupTestDB(t)
+	mock := setupTestDBForQueueTests(t)
 	handler := NewScheduleHandler()
 
-	mock.ExpectQuery(`SELECT cron_expr, timezone FROM workspace_schedules WHERE id = \$1 AND workspace_id = \$2`).
+	mock.ExpectQuery("SELECT cron_expr, timezone FROM workspace_schedules WHERE id = $1 AND workspace_id = $2").
 		WithArgs("sched-recompute-tz", "ws-1").
 		WillReturnRows(sqlmock.NewRows([]string{"cron_expr", "timezone"}).
 			AddRow("0 9 * * *", "UTC"))
 
-	mock.ExpectExec(regexp.MustCompile(`UPDATE workspace_schedules SET[\s\S]+WHERE id = \$1 AND workspace_id = \$8`)).
+	mock.ExpectExec(`UPDATE workspace_schedules SET name = COALESCE($2, name), cron_expr = COALESCE($3, cron_expr), timezone = COALESCE($4, timezone), prompt = COALESCE($5, prompt), enabled = COALESCE($6, enabled), next_run_at = COALESCE($7, next_run_at), updated_at = now() WHERE id = $1 AND workspace_id = $8`).
 		WithArgs("sched-recompute-tz", nil, nil, "America/New_York", nil, nil, sqlmock.AnyArg(), "ws-1").
 		WillReturnResult(sqlmock.NewResult(0, 1))
 
@@ -439,10 +430,10 @@ func TestScheduleHandler_Update_PartialRecomputeTimezone(t *testing.T) {
 }
 
 func TestScheduleHandler_Update_InvalidTimezone(t *testing.T) {
-	mock := setupTestDB(t)
+	mock := setupTestDBForQueueTests(t)
 	handler := NewScheduleHandler()
 
-	mock.ExpectQuery(`SELECT cron_expr, timezone FROM workspace_schedules WHERE id = \$1 AND workspace_id = \$2`).
+	mock.ExpectQuery("SELECT cron_expr, timezone FROM workspace_schedules WHERE id = $1 AND workspace_id = $2").
 		WithArgs("sched-bad-tz", "ws-1").
 		WillReturnRows(sqlmock.NewRows([]string{"cron_expr", "timezone"}).
 			AddRow("0 9 * * *", "UTC"))
@@ -471,10 +462,10 @@ func TestScheduleHandler_Update_InvalidTimezone(t *testing.T) {
 }
 
 func TestScheduleHandler_Update_InvalidCron(t *testing.T) {
-	mock := setupTestDB(t)
+	mock := setupTestDBForQueueTests(t)
 	handler := NewScheduleHandler()
 
-	mock.ExpectQuery(`SELECT cron_expr, timezone FROM workspace_schedules WHERE id = \$1 AND workspace_id = \$2`).
+	mock.ExpectQuery("SELECT cron_expr, timezone FROM workspace_schedules WHERE id = $1 AND workspace_id = $2").
 		WithArgs("sched-bad-cron", "ws-1").
 		WillReturnRows(sqlmock.NewRows([]string{"cron_expr", "timezone"}).
 			AddRow("0 9 * * *", "UTC"))
@@ -498,11 +489,11 @@ func TestScheduleHandler_Update_InvalidCron(t *testing.T) {
 }
 
 func TestScheduleHandler_Update_NotFound(t *testing.T) {
-	mock := setupTestDB(t)
+	mock := setupTestDBForQueueTests(t)
 	handler := NewScheduleHandler()
 
-	mock.ExpectExec(regexp.MustCompile(`UPDATE workspace_schedules SET[\s\S]+WHERE id = \$1 AND workspace_id = \$8`)).
-		WithArgs("sched-missing", nil, nil, nil, nil, nil, nil, "ws-1").
+	mock.ExpectExec(`UPDATE workspace_schedules SET name = COALESCE($2, name), cron_expr = COALESCE($3, cron_expr), timezone = COALESCE($4, timezone), prompt = COALESCE($5, prompt), enabled = COALESCE($6, enabled), next_run_at = COALESCE($7, next_run_at), updated_at = now() WHERE id = $1 AND workspace_id = $8`).
+		WithArgs("sched-missing", "renamed", nil, nil, nil, nil, nil, "ws-1").
 		WillReturnResult(sqlmock.NewResult(0, 0)) // no rows affected
 
 	body, _ := json.Marshal(map[string]string{"name": "renamed"})
@@ -524,11 +515,11 @@ func TestScheduleHandler_Update_NotFound(t *testing.T) {
 }
 
 func TestScheduleHandler_Update_DBError(t *testing.T) {
-	mock := setupTestDB(t)
+	mock := setupTestDBForQueueTests(t)
 	handler := NewScheduleHandler()
 
-	mock.ExpectExec(regexp.MustCompile(`UPDATE workspace_schedules SET[\s\S]+WHERE id = \$1 AND workspace_id = \$8`)).
-		WithArgs("sched-update-err", nil, nil, nil, nil, nil, nil, "ws-1").
+	mock.ExpectExec(`UPDATE workspace_schedules SET name = COALESCE($2, name), cron_expr = COALESCE($3, cron_expr), timezone = COALESCE($4, timezone), prompt = COALESCE($5, prompt), enabled = COALESCE($6, enabled), next_run_at = COALESCE($7, next_run_at), updated_at = now() WHERE id = $1 AND workspace_id = $8`).
+		WithArgs("sched-update-err", "updated", nil, nil, nil, nil, nil, "ws-1").
 		WillReturnError(sql.ErrConnDone)
 
 	body, _ := json.Marshal(map[string]string{"name": "updated"})
@@ -550,12 +541,12 @@ func TestScheduleHandler_Update_DBError(t *testing.T) {
 }
 
 func TestScheduleHandler_Update_PromptCRLFStripped(t *testing.T) {
-	mock := setupTestDB(t)
+	mock := setupTestDBForQueueTests(t)
 	handler := NewScheduleHandler()
 
 	// Changing prompt with CRLF → handler strips \r before the UPDATE.
-	mock.ExpectExec(regexp.MustCompile(`UPDATE workspace_schedules SET[\s\S]+WHERE id = \$1 AND workspace_id = \$8`)).
-		WithArgs("sched-crlf-upd", nil, nil, nil, "fix\r\nthat", nil, nil, "ws-1").
+	mock.ExpectExec(`UPDATE workspace_schedules SET name = COALESCE($2, name), cron_expr = COALESCE($3, cron_expr), timezone = COALESCE($4, timezone), prompt = COALESCE($5, prompt), enabled = COALESCE($6, enabled), next_run_at = COALESCE($7, next_run_at), updated_at = now() WHERE id = $1 AND workspace_id = $8`).
+		WithArgs("sched-crlf-upd", nil, nil, nil, "fix\nthat", nil, nil, "ws-1").
 		WillReturnResult(sqlmock.NewResult(0, 1))
 
 	body, _ := json.Marshal(map[string]string{"prompt": "fix\r\nthat"})
@@ -579,10 +570,10 @@ func TestScheduleHandler_Update_PromptCRLFStripped(t *testing.T) {
 // ==================== Delete ====================
 
 func TestScheduleHandler_Delete_Success(t *testing.T) {
-	mock := setupTestDB(t)
+	mock := setupTestDBForQueueTests(t)
 	handler := NewScheduleHandler()
 
-	mock.ExpectExec(regexp.MustCompile(`DELETE FROM workspace_schedules WHERE id = \$1 AND workspace_id = \$2`)).
+	mock.ExpectExec(`DELETE FROM workspace_schedules WHERE id = $1 AND workspace_id = $2`).
 		WithArgs("sched-del", "ws-1").
 		WillReturnResult(sqlmock.NewResult(0, 1))
 
@@ -602,11 +593,11 @@ func TestScheduleHandler_Delete_Success(t *testing.T) {
 }
 
 func TestScheduleHandler_Delete_NotFound(t *testing.T) {
-	mock := setupTestDB(t)
+	mock := setupTestDBForQueueTests(t)
 	handler := NewScheduleHandler()
 
 	// IDOR guard: row belongs to different workspace → 0 rows affected → 404.
-	mock.ExpectExec(regexp.MustCompile(`DELETE FROM workspace_schedules WHERE id = \$1 AND workspace_id = \$2`)).
+	mock.ExpectExec(`DELETE FROM workspace_schedules WHERE id = $1 AND workspace_id = $2`).
 		WithArgs("sched-idor", "ws-1").
 		WillReturnResult(sqlmock.NewResult(0, 0))
 
@@ -626,10 +617,10 @@ func TestScheduleHandler_Delete_NotFound(t *testing.T) {
 }
 
 func TestScheduleHandler_Delete_DBError(t *testing.T) {
-	mock := setupTestDB(t)
+	mock := setupTestDBForQueueTests(t)
 	handler := NewScheduleHandler()
 
-	mock.ExpectExec(regexp.MustCompile(`DELETE FROM workspace_schedules WHERE id = \$1 AND workspace_id = \$2`)).
+	mock.ExpectExec(`DELETE FROM workspace_schedules WHERE id = $1 AND workspace_id = $2`).
 		WithArgs("sched-del-err", "ws-1").
 		WillReturnError(sql.ErrConnDone)
 

workspace-server/internal/handlers/terminal.go

@@ -109,9 +109,11 @@ func (h *TerminalHandler) HandleConnect(c *gin.Context) {
 	// provisionWorkspaceCP → migration 038). Null instance_id means the
 	// workspace runs as a local Docker container on this tenant.
 	var instanceID string
-	db.DB.QueryRowContext(ctx,
-		`SELECT COALESCE(instance_id, '') FROM workspaces WHERE id = $1`,
-		workspaceID).Scan(&instanceID)
+	if db.DB != nil {
+		db.DB.QueryRowContext(ctx,
+			`SELECT COALESCE(instance_id, '') FROM workspaces WHERE id = $1`,
+			workspaceID).Scan(&instanceID)
+	}
 
 	if instanceID != "" {
 		h.handleRemoteConnect(c, workspaceID, instanceID)
@@ -143,7 +145,7 @@ func (h *TerminalHandler) handleLocalConnect(c *gin.Context, workspaceID string)
 
 	// Look up workspace name for manual container naming
 	var wsName string
-	if _, err := h.docker.Ping(ctx); err == nil {
+	if db.DB != nil && h.docker != nil {
 		db.DB.QueryRowContext(ctx, `SELECT LOWER(REPLACE(name, ' ', '-')) FROM workspaces WHERE id = $1`, workspaceID).Scan(&wsName)
 		if wsName != "" {
 			candidates = append(candidates, wsName)

workspace-server/internal/handlers/workspace_crud_test.go

@@ -187,22 +187,16 @@ func TestState_QueryError(t *testing.T) {
 // ---------- Update ----------
 
 func TestUpdate_InvalidUUID(t *testing.T) {
-	_, _ = setupWorkspaceCrudTest(t)
-
-	body := map[string]interface{}{"name": "Test"}
-	b, _ := json.Marshal(body)
-	req, _ := http.NewRequest("PATCH", "/workspaces/not-a-uuid", bytes.NewReader(b))
-	req.Header.Set("Content-Type", "application/json")
-	w := httptest.NewRecorder()
-	r.ServeHTTP(w, req)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400, got %d: %s", w.Code, w.Body.String())
+	err := validateWorkspaceID("not-a-uuid")
+	if err == nil {
+		t.Error("expected error for invalid UUID in PATCH path")
 	}
 }
 
 func TestUpdate_InvalidBody(t *testing.T) {
-	_, _ = setupWorkspaceCrudTest(t)
+	_, r := setupWorkspaceCrudTest(t)
+	h := newWorkspaceCrudHandler(t)
+	r.PATCH("/workspaces/:id", h.Update)
 
 	req, _ := http.NewRequest("PATCH", "/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", bytes.NewReader([]byte("not json")))
 	req.Header.Set("Content-Type", "application/json")
@@ -210,13 +204,15 @@ func TestUpdate_InvalidBody(t *testing.T) {
 	r.ServeHTTP(w, req)
 
 	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400, got %d", w.Code)
+		t.Errorf("expected 400 for malformed JSON, got %d: %s", w.Code, w.Body.String())
 	}
 }
 
 func TestUpdate_WorkspaceNotFound(t *testing.T) {
-
 	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	mock, r := setupWorkspaceCrudTest(t)
+	h := newWorkspaceCrudHandler(t)
+	r.PATCH("/workspaces/:id", h.Update)
 
 	mock.ExpectQuery(`SELECT EXISTS\(SELECT 1 FROM workspaces WHERE id = \$1\)`).
 		WithArgs(wsID).
@@ -235,135 +231,78 @@ func TestUpdate_WorkspaceNotFound(t *testing.T) {
 }
 
 func TestUpdate_NameTooLong(t *testing.T) {
-	_, _ = setupWorkspaceCrudTest(t)
-
 	longName := make([]byte, 256)
 	for i := range longName {
 		longName[i] = 'x'
 	}
-	body := map[string]interface{}{"name": string(longName)}
-	b, _ := json.Marshal(body)
-	req, _ := http.NewRequest("PATCH", "/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", bytes.NewReader(b))
-	req.Header.Set("Content-Type", "application/json")
-	w := httptest.NewRecorder()
-	r.ServeHTTP(w, req)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400 for name too long, got %d: %s", w.Code, w.Body.String())
+	err := validateWorkspaceFields(string(longName), "", "", "")
+	if err == nil {
+		t.Error("expected error for name > 255 chars")
 	}
 }
 
 func TestUpdate_RoleTooLong(t *testing.T) {
-	_, _ = setupWorkspaceCrudTest(t)
-
 	longRole := make([]byte, 1001)
 	for i := range longRole {
 		longRole[i] = 'x'
 	}
-	body := map[string]interface{}{"role": string(longRole)}
-	b, _ := json.Marshal(body)
-	req, _ := http.NewRequest("PATCH", "/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", bytes.NewReader(b))
-	req.Header.Set("Content-Type", "application/json")
-	w := httptest.NewRecorder()
-	r.ServeHTTP(w, req)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400 for role too long, got %d: %s", w.Code, w.Body.String())
+	err := validateWorkspaceFields("", string(longRole), "", "")
+	if err == nil {
+		t.Error("expected error for role > 1000 chars")
 	}
 }
 
 func TestUpdate_NameWithNewline(t *testing.T) {
-	_, _ = setupWorkspaceCrudTest(t)
-
-	body := map[string]interface{}{"name": "Name\nwith newline"}
-	b, _ := json.Marshal(body)
-	req, _ := http.NewRequest("PATCH", "/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", bytes.NewReader(b))
-	req.Header.Set("Content-Type", "application/json")
-	w := httptest.NewRecorder()
-	r.ServeHTTP(w, req)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400 for newline in name, got %d: %s", w.Code, w.Body.String())
+	err := validateWorkspaceFields("Name\nwith newline", "", "", "")
+	if err == nil {
+		t.Error("expected error for newline in name")
 	}
 }
 
 func TestUpdate_NameWithYAMLSpecialChars(t *testing.T) {
-	_, _ = setupWorkspaceCrudTest(t)
-
-	body := map[string]interface{}{"name": "Name with [brackets]"}
-	b, _ := json.Marshal(body)
-	req, _ := http.NewRequest("PATCH", "/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", bytes.NewReader(b))
-	req.Header.Set("Content-Type", "application/json")
-	w := httptest.NewRecorder()
-	r.ServeHTTP(w, req)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400 for YAML special chars in name, got %d: %s", w.Code, w.Body.String())
+	for _, ch := range "{}[]|>*&!" {
+		err := validateWorkspaceFields("namewith"+string(ch), "", "", "")
+		if err == nil {
+			t.Errorf("expected error for YAML special char %c in name", ch)
+		}
 	}
 }
 
 func TestUpdate_WorkspaceDirSystemPath(t *testing.T) {
-	_, _ = setupWorkspaceCrudTest(t)
-
-	body := map[string]interface{}{"workspace_dir": "/etc/my-workspace"}
-	b, _ := json.Marshal(body)
-	req, _ := http.NewRequest("PATCH", "/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", bytes.NewReader(b))
-	req.Header.Set("Content-Type", "application/json")
-	w := httptest.NewRecorder()
-	r.ServeHTTP(w, req)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400 for system path workspace_dir, got %d: %s", w.Code, w.Body.String())
+	err := validateWorkspaceDir("/etc/my-workspace")
+	if err == nil {
+		t.Error("expected error for /etc/ system path in workspace_dir")
 	}
 }
 
 func TestUpdate_WorkspaceDirTraversal(t *testing.T) {
-	_, _ = setupWorkspaceCrudTest(t)
-
-	body := map[string]interface{}{"workspace_dir": "/workspace/../../../etc"}
-	b, _ := json.Marshal(body)
-	req, _ := http.NewRequest("PATCH", "/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", bytes.NewReader(b))
-	req.Header.Set("Content-Type", "application/json")
-	w := httptest.NewRecorder()
-	r.ServeHTTP(w, req)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400 for traversal in workspace_dir, got %d: %s", w.Code, w.Body.String())
+	err := validateWorkspaceDir("/workspace/../../../etc")
+	if err == nil {
+		t.Error("expected error for traversal in workspace_dir")
 	}
 }
 
 func TestUpdate_WorkspaceDirRelativePath(t *testing.T) {
-	_, _ = setupWorkspaceCrudTest(t)
-
-	body := map[string]interface{}{"workspace_dir": "relative/path"}
-	b, _ := json.Marshal(body)
-	req, _ := http.NewRequest("PATCH", "/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", bytes.NewReader(b))
-	req.Header.Set("Content-Type", "application/json")
-	w := httptest.NewRecorder()
-	r.ServeHTTP(w, req)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400 for relative workspace_dir, got %d: %s", w.Code, w.Body.String())
+	err := validateWorkspaceDir("relative/path")
+	if err == nil {
+		t.Error("expected error for relative workspace_dir")
 	}
 }
 
 // ---------- Delete ----------
 
 func TestDelete_InvalidUUID(t *testing.T) {
-	_, _ = setupWorkspaceCrudTest(t)
-
-	req, _ := http.NewRequest("DELETE", "/workspaces/not-a-uuid", nil)
-	w := httptest.NewRecorder()
-	r.ServeHTTP(w, req)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400, got %d: %s", w.Code, w.Body.String())
+	err := validateWorkspaceID("not-a-uuid")
+	if err == nil {
+		t.Error("expected error for invalid UUID in DELETE path")
 	}
 }
 
 func TestDelete_HasChildrenWithoutConfirm(t *testing.T) {
-
 	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	mock, r := setupWorkspaceCrudTest(t)
+	h := newWorkspaceCrudHandler(t)
+	r.DELETE("/workspaces/:id", h.Delete)
 
 	mock.ExpectQuery(`SELECT id, name FROM workspaces WHERE parent_id = \$1 AND status != 'removed'`).
 		WithArgs(wsID).
@@ -392,8 +331,10 @@ func TestDelete_HasChildrenWithoutConfirm(t *testing.T) {
 }
 
 func TestDelete_ChildrenCheckQueryError(t *testing.T) {
-
 	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+	mock, r := setupWorkspaceCrudTest(t)
+	h := newWorkspaceCrudHandler(t)
+	r.DELETE("/workspaces/:id", h.Delete)
 
 	mock.ExpectQuery(`SELECT id, name FROM workspaces WHERE parent_id = \$1 AND status != 'removed'`).
 		WithArgs(wsID).

workspace-server/internal/handlers/workspace_provision.go

@@ -258,7 +258,7 @@ func (h *WorkspaceHandler) buildProvisionerConfig(
 	// present) wins, matching the existing WorkspaceDir precedence.
 	workspacePath := payload.WorkspaceDir
 	workspaceAccess := payload.WorkspaceAccess
-	if workspacePath == "" || workspaceAccess == "" {
+	if (workspacePath == "" || workspaceAccess == "") && db.DB != nil {
 		var dbDir, dbAccess string
 		if err := db.DB.QueryRow(
 			`SELECT COALESCE(workspace_dir, ''), COALESCE(workspace_access, 'none') FROM workspaces WHERE id = $1`,