path: root/internal/api/server_test.go

package api

import (
	"bytes"
	"encoding/json"
	"fmt"
	"log/slog"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"testing"

	"context"

	"github.com/thepeterstone/claudomator/internal/executor"
	"github.com/thepeterstone/claudomator/internal/storage"
	"github.com/thepeterstone/claudomator/internal/task"
)

func testServer(t *testing.T) (*Server, *storage.DB) {
	t.Helper()
	dbPath := filepath.Join(t.TempDir(), "test.db")
	store, err := storage.Open(dbPath)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { store.Close() })

	logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelError}))
	runner := &mockRunner{}
	pool := executor.NewPool(2, runner, store, logger)
	srv := NewServer(store, pool, logger, "claude")
	return srv, store
}

type mockRunner struct{}

func (m *mockRunner) Run(_ context.Context, _ *task.Task, _ *storage.Execution) error {
	return nil
}

func TestHealthEndpoint(t *testing.T) {
	srv, _ := testServer(t)
	req := httptest.NewRequest("GET", "/api/health", nil)
	w := httptest.NewRecorder()

	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusOK {
		t.Errorf("status: want 200, got %d", w.Code)
	}
	var body map[string]string
	json.NewDecoder(w.Body).Decode(&body)
	if body["status"] != "ok" {
		t.Errorf("want status=ok, got %v", body)
	}
}

func TestCreateTask_Success(t *testing.T) {
	srv, _ := testServer(t)

	payload := `{
		"name": "API Task",
		"description": "Created via API",
		"claude": {
			"instructions": "do the thing",
			"model": "sonnet"
		},
		"timeout": "5m",
		"tags": ["api"]
	}`
	req := httptest.NewRequest("POST", "/api/tasks", bytes.NewBufferString(payload))
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()

	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusCreated {
		t.Fatalf("status: want 201, got %d; body: %s", w.Code, w.Body.String())
	}

	var created task.Task
	json.NewDecoder(w.Body).Decode(&created)
	if created.Name != "API Task" {
		t.Errorf("name: want 'API Task', got %q", created.Name)
	}
	if created.ID == "" {
		t.Error("expected auto-generated ID")
	}
}

func TestCreateTask_InvalidJSON(t *testing.T) {
	srv, _ := testServer(t)

	req := httptest.NewRequest("POST", "/api/tasks", bytes.NewBufferString("{bad json"))
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusBadRequest {
		t.Errorf("status: want 400, got %d", w.Code)
	}
}

func TestCreateTask_ValidationFailure(t *testing.T) {
	srv, _ := testServer(t)

	payload := `{"name": "", "claude": {"instructions": ""}}`
	req := httptest.NewRequest("POST", "/api/tasks", bytes.NewBufferString(payload))
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusBadRequest {
		t.Errorf("status: want 400, got %d", w.Code)
	}
}

func TestListTasks_Empty(t *testing.T) {
	srv, _ := testServer(t)

	req := httptest.NewRequest("GET", "/api/tasks", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusOK {
		t.Errorf("status: want 200, got %d", w.Code)
	}

	var tasks []task.Task
	json.NewDecoder(w.Body).Decode(&tasks)
	if len(tasks) != 0 {
		t.Errorf("want 0 tasks, got %d", len(tasks))
	}
}

func TestGetTask_NotFound(t *testing.T) {
	srv, _ := testServer(t)

	req := httptest.NewRequest("GET", "/api/tasks/nonexistent", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusNotFound {
		t.Errorf("status: want 404, got %d", w.Code)
	}
}

func TestListTasks_WithTasks(t *testing.T) {
	srv, store := testServer(t)

	// Create tasks directly in store.
	for i := 0; i < 3; i++ {
		tk := &task.Task{
			ID: fmt.Sprintf("lt-%d", i), Name: fmt.Sprintf("T%d", i),
			Claude: task.ClaudeConfig{Instructions: "x"}, Priority: task.PriorityNormal,
			Retry: task.RetryConfig{MaxAttempts: 1, Backoff: "linear"},
			Tags: []string{}, DependsOn: []string{}, State: task.StatePending,
		}
		store.CreateTask(tk)
	}

	req := httptest.NewRequest("GET", "/api/tasks", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	var tasks []task.Task
	json.NewDecoder(w.Body).Decode(&tasks)
	if len(tasks) != 3 {
		t.Errorf("want 3 tasks, got %d", len(tasks))
	}
}

func createTaskWithState(t *testing.T, store *storage.DB, id string, state task.State) *task.Task {
	t.Helper()
	tk := &task.Task{
		ID:    id,
		Name:  "test-task-" + id,
		Claude: task.ClaudeConfig{Instructions: "do something"},
		Priority: task.PriorityNormal,
		Retry: task.RetryConfig{MaxAttempts: 1, Backoff: "linear"},
		Tags: []string{}, DependsOn: []string{}, State: task.StatePending,
	}
	if err := store.CreateTask(tk); err != nil {
		t.Fatalf("createTaskWithState: CreateTask: %v", err)
	}
	if state != task.StatePending {
		if err := store.UpdateTaskState(id, state); err != nil {
			t.Fatalf("createTaskWithState: UpdateTaskState(%s): %v", state, err)
		}
	}
	tk.State = state
	return tk
}

func TestRunTask_PendingTask_Returns202(t *testing.T) {
	srv, store := testServer(t)
	createTaskWithState(t, store, "run-pending", task.StatePending)

	req := httptest.NewRequest("POST", "/api/tasks/run-pending/run", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusAccepted {
		t.Errorf("status: want 202, got %d; body: %s", w.Code, w.Body.String())
	}
}

func TestRunTask_FailedTask_Returns202(t *testing.T) {
	srv, store := testServer(t)
	createTaskWithState(t, store, "run-failed", task.StateFailed)

	req := httptest.NewRequest("POST", "/api/tasks/run-failed/run", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusAccepted {
		t.Errorf("status: want 202, got %d; body: %s", w.Code, w.Body.String())
	}
}

func TestRunTask_TimedOutTask_Returns202(t *testing.T) {
	srv, store := testServer(t)
	// TIMED_OUT → QUEUED is a valid transition (retry path).
	// We need to get the task into TIMED_OUT state; storage allows direct state writes.
	createTaskWithState(t, store, "run-timedout", task.StateTimedOut)

	req := httptest.NewRequest("POST", "/api/tasks/run-timedout/run", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusAccepted {
		t.Errorf("status: want 202, got %d; body: %s", w.Code, w.Body.String())
	}
}

func TestRunTask_CompletedTask_Returns409(t *testing.T) {
	srv, store := testServer(t)
	createTaskWithState(t, store, "run-completed", task.StateCompleted)

	req := httptest.NewRequest("POST", "/api/tasks/run-completed/run", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusConflict {
		t.Errorf("status: want 409, got %d; body: %s", w.Code, w.Body.String())
	}
	var body map[string]string
	json.NewDecoder(w.Body).Decode(&body)
	wantMsg := "task cannot be queued from state COMPLETED"
	if body["error"] != wantMsg {
		t.Errorf("error body: want %q, got %q", wantMsg, body["error"])
	}
}

func TestAcceptTask_ReadyTask_Returns200(t *testing.T) {
	srv, store := testServer(t)
	createTaskWithState(t, store, "accept-ready", task.StateReady)

	req := httptest.NewRequest("POST", "/api/tasks/accept-ready/accept", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusOK {
		t.Errorf("status: want 200, got %d; body: %s", w.Code, w.Body.String())
	}

	got, _ := store.GetTask("accept-ready")
	if got.State != task.StateCompleted {
		t.Errorf("task state: want COMPLETED, got %v", got.State)
	}
}

func TestAcceptTask_NonReadyTask_Returns409(t *testing.T) {
	srv, store := testServer(t)
	createTaskWithState(t, store, "accept-pending", task.StatePending)

	req := httptest.NewRequest("POST", "/api/tasks/accept-pending/accept", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusConflict {
		t.Errorf("status: want 409, got %d; body: %s", w.Code, w.Body.String())
	}
}

func TestRejectTask_ReadyTask_Returns200(t *testing.T) {
	srv, store := testServer(t)
	createTaskWithState(t, store, "reject-ready", task.StateReady)

	body := bytes.NewBufferString(`{"comment": "needs more detail"}`)
	req := httptest.NewRequest("POST", "/api/tasks/reject-ready/reject", body)
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusOK {
		t.Errorf("status: want 200, got %d; body: %s", w.Code, w.Body.String())
	}

	got, _ := store.GetTask("reject-ready")
	if got.State != task.StatePending {
		t.Errorf("task state: want PENDING, got %v", got.State)
	}
	if got.RejectionComment != "needs more detail" {
		t.Errorf("rejection_comment: want 'needs more detail', got %q", got.RejectionComment)
	}
}

func TestRejectTask_NonReadyTask_Returns409(t *testing.T) {
	srv, store := testServer(t)
	createTaskWithState(t, store, "reject-pending", task.StatePending)

	body := bytes.NewBufferString(`{"comment": "comment"}`)
	req := httptest.NewRequest("POST", "/api/tasks/reject-pending/reject", body)
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusConflict {
		t.Errorf("status: want 409, got %d; body: %s", w.Code, w.Body.String())
	}
}

func TestCORS_Headers(t *testing.T) {
	srv, _ := testServer(t)

	req := httptest.NewRequest("OPTIONS", "/api/tasks", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Header().Get("Access-Control-Allow-Origin") != "*" {
		t.Error("missing CORS origin header")
	}
	if w.Code != http.StatusOK {
		t.Errorf("OPTIONS status: want 200, got %d", w.Code)
	}
}

func TestAnswerQuestion_NoTask_Returns404(t *testing.T) {
	srv, _ := testServer(t)

	req := httptest.NewRequest("POST", "/api/tasks/nonexistent/answer", bytes.NewBufferString(`{"answer":"blue"}`))
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()

	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusNotFound {
		t.Errorf("status: want 404, got %d; body: %s", w.Code, w.Body.String())
	}
}

func TestAnswerQuestion_TaskNotBlocked_Returns409(t *testing.T) {
	srv, store := testServer(t)
	createTaskWithState(t, store, "answer-task-1", task.StatePending)

	req := httptest.NewRequest("POST", "/api/tasks/answer-task-1/answer", bytes.NewBufferString(`{"answer":"blue"}`))
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()

	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusConflict {
		t.Errorf("status: want 409, got %d; body: %s", w.Code, w.Body.String())
	}
}

func TestAnswerQuestion_MissingAnswer_Returns400(t *testing.T) {
	srv, store := testServer(t)
	createTaskWithState(t, store, "answer-task-2", task.StateBlocked)

	req := httptest.NewRequest("POST", "/api/tasks/answer-task-2/answer", bytes.NewBufferString(`{}`))
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()

	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusBadRequest {
		t.Errorf("status: want 400, got %d; body: %s", w.Code, w.Body.String())
	}
}

func TestAnswerQuestion_BlockedTask_QueuesResume(t *testing.T) {
	srv, store := testServer(t)
	createTaskWithState(t, store, "answer-task-3", task.StateBlocked)

	// Create an execution with a session ID, as the runner would have.
	exec := &storage.Execution{
		ID:        "exec-blocked-1",
		TaskID:    "answer-task-3",
		SessionID: "550e8400-e29b-41d4-a716-446655440001",
		Status:    "BLOCKED",
	}
	if err := store.CreateExecution(exec); err != nil {
		t.Fatalf("create execution: %v", err)
	}

	req := httptest.NewRequest("POST", "/api/tasks/answer-task-3/answer", bytes.NewBufferString(`{"answer":"main"}`))
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()

	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusOK {
		t.Errorf("status: want 200, got %d; body: %s", w.Code, w.Body.String())
	}

	// Task should now be QUEUED (or RUNNING since the mock runner is instant).
	got, _ := store.GetTask("answer-task-3")
	if got.State != task.StateQueued && got.State != task.StateRunning && got.State != task.StateReady {
		t.Errorf("task state: want QUEUED/RUNNING/READY after answer, got %v", got.State)
	}
}

func TestHandleStartNextTask_Success(t *testing.T) {
	dir := t.TempDir()
	script := filepath.Join(dir, "start-next-task")
	if err := os.WriteFile(script, []byte("#!/bin/sh\necho 'claudomator start abc-123'\n"), 0755); err != nil {
		t.Fatal(err)
	}

	srv, _ := testServer(t)
	srv.startNextTaskScript = script

	req := httptest.NewRequest("POST", "/api/scripts/start-next-task", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf("want 200, got %d; body: %s", w.Code, w.Body.String())
	}
	var body map[string]interface{}
	json.NewDecoder(w.Body).Decode(&body)
	if body["output"] != "claudomator start abc-123\n" {
		t.Errorf("unexpected output: %v", body["output"])
	}
	if body["exit_code"] != float64(0) {
		t.Errorf("unexpected exit_code: %v", body["exit_code"])
	}
}

func TestHandleStartNextTask_NoTask(t *testing.T) {
	dir := t.TempDir()
	script := filepath.Join(dir, "start-next-task")
	if err := os.WriteFile(script, []byte("#!/bin/sh\necho 'No task to start.'\n"), 0755); err != nil {
		t.Fatal(err)
	}

	srv, _ := testServer(t)
	srv.startNextTaskScript = script

	req := httptest.NewRequest("POST", "/api/scripts/start-next-task", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf("want 200, got %d; body: %s", w.Code, w.Body.String())
	}
	var body map[string]interface{}
	json.NewDecoder(w.Body).Decode(&body)
	if body["output"] != "No task to start.\n" {
		t.Errorf("unexpected output: %v", body["output"])
	}
}

func TestResumeTimedOut_NoTask_Returns404(t *testing.T) {
	srv, _ := testServer(t)

	req := httptest.NewRequest("POST", "/api/tasks/nonexistent/resume", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusNotFound {
		t.Errorf("status: want 404, got %d; body: %s", w.Code, w.Body.String())
	}
}

func TestResumeTimedOut_TaskNotTimedOut_Returns409(t *testing.T) {
	srv, store := testServer(t)
	createTaskWithState(t, store, "resume-task-1", task.StatePending)

	req := httptest.NewRequest("POST", "/api/tasks/resume-task-1/resume", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusConflict {
		t.Errorf("status: want 409, got %d; body: %s", w.Code, w.Body.String())
	}
}

func TestResumeTimedOut_NoSession_Returns500(t *testing.T) {
	srv, store := testServer(t)
	createTaskWithState(t, store, "resume-task-2", task.StateTimedOut)

	// No execution created — so no session ID.
	req := httptest.NewRequest("POST", "/api/tasks/resume-task-2/resume", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusInternalServerError {
		t.Errorf("status: want 500, got %d; body: %s", w.Code, w.Body.String())
	}
}

func TestResumeTimedOut_Success_Returns202(t *testing.T) {
	srv, store := testServer(t)
	createTaskWithState(t, store, "resume-task-3", task.StateTimedOut)

	exec := &storage.Execution{
		ID:        "exec-timedout-1",
		TaskID:    "resume-task-3",
		SessionID: "550e8400-e29b-41d4-a716-446655440002",
		Status:    "TIMED_OUT",
	}
	if err := store.CreateExecution(exec); err != nil {
		t.Fatalf("create execution: %v", err)
	}

	req := httptest.NewRequest("POST", "/api/tasks/resume-task-3/resume", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusAccepted {
		t.Errorf("status: want 202, got %d; body: %s", w.Code, w.Body.String())
	}

	got, _ := store.GetTask("resume-task-3")
	if got.State != task.StateQueued && got.State != task.StateRunning && got.State != task.StateReady {
		t.Errorf("task state: want QUEUED/RUNNING/READY after resume, got %v", got.State)
	}
}

func TestHandleStartNextTask_ScriptNotFound(t *testing.T) {
	srv, _ := testServer(t)
	srv.startNextTaskScript = "/nonexistent/start-next-task"

	req := httptest.NewRequest("POST", "/api/scripts/start-next-task", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusInternalServerError {
		t.Errorf("want 500, got %d; body: %s", w.Code, w.Body.String())
	}
}

func TestDeleteTask_Success(t *testing.T) {
	srv, store := testServer(t)

	// Create a task to delete.
	created := createTestTask(t, srv, `{"name":"Delete Me","claude":{"instructions":"x","model":"sonnet"}}`)

	req := httptest.NewRequest("DELETE", "/api/tasks/"+created.ID, nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusNoContent {
		t.Fatalf("want 204, got %d; body: %s", w.Code, w.Body.String())
	}

	_, err := store.GetTask(created.ID)
	if err == nil {
		t.Error("task should be deleted from store")
	}
}

func TestDeleteTask_NotFound(t *testing.T) {
	srv, _ := testServer(t)

	req := httptest.NewRequest("DELETE", "/api/tasks/does-not-exist", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusNotFound {
		t.Errorf("want 404, got %d", w.Code)
	}
}

func TestDeleteTask_RunningTaskRejected(t *testing.T) {
	srv, store := testServer(t)

	created := createTestTask(t, srv, `{"name":"Running Task","claude":{"instructions":"x","model":"sonnet"}}`)
	store.UpdateTaskState(created.ID, "RUNNING")

	req := httptest.NewRequest("DELETE", "/api/tasks/"+created.ID, nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusConflict {
		t.Errorf("want 409 for running task, got %d", w.Code)
	}
}

// createTestTask is a helper that POSTs a task and returns the parsed Task.
func createTestTask(t *testing.T, srv *Server, payload string) task.Task {
	t.Helper()
	req := httptest.NewRequest("POST", "/api/tasks", bytes.NewBufferString(payload))
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)
	if w.Code != http.StatusCreated {
		t.Fatalf("createTestTask: want 201, got %d; body: %s", w.Code, w.Body.String())
	}
	var tk task.Task
	json.NewDecoder(w.Body).Decode(&tk)
	return tk
}

func TestServer_CancelTask_Pending_TransitionsToCancelled(t *testing.T) {
	srv, store := testServer(t)
	createTaskWithState(t, store, "cancel-pending-1", task.StatePending)

	req := httptest.NewRequest("POST", "/api/tasks/cancel-pending-1/cancel", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf("status: want 200, got %d; body: %s", w.Code, w.Body.String())
	}
	updated, err := store.GetTask("cancel-pending-1")
	if err != nil {
		t.Fatal(err)
	}
	if updated.State != task.StateCancelled {
		t.Errorf("state: want CANCELLED, got %s", updated.State)
	}
}

func TestServer_CancelTask_Queued_TransitionsToCancelled(t *testing.T) {
	srv, store := testServer(t)
	createTaskWithState(t, store, "cancel-queued-1", task.StateQueued)

	req := httptest.NewRequest("POST", "/api/tasks/cancel-queued-1/cancel", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf("status: want 200, got %d; body: %s", w.Code, w.Body.String())
	}
	updated, err := store.GetTask("cancel-queued-1")
	if err != nil {
		t.Fatal(err)
	}
	if updated.State != task.StateCancelled {
		t.Errorf("state: want CANCELLED, got %s", updated.State)
	}
}

func TestServer_CancelTask_Completed_Returns409(t *testing.T) {
	srv, store := testServer(t)
	createTaskWithState(t, store, "cancel-completed-1", task.StateCompleted)

	req := httptest.NewRequest("POST", "/api/tasks/cancel-completed-1/cancel", nil)
	w := httptest.NewRecorder()
	srv.Handler().ServeHTTP(w, req)

	if w.Code != http.StatusConflict {
		t.Errorf("status: want 409, got %d; body: %s", w.Code, w.Body.String())
	}
}