magic-agent 2.3.2 → 2.3.9

package/internal/client/jobs_test.go

@@ -0,0 +1,369 @@
+package client
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+/* 服务端作业队列的回归闸门（2026-10-23）：
+   · 同一 workspace 串行、不同 workspace 并行；
+   · request_id 幂等（重复提交不多跑一遍）；
+   · 排队中可取消，取消后不会偷偷开跑；
+   · 落盘 + 重启恢复（queued 留着、running 标失败）。 */
+
+// jobCore 假 core：记下每一次「真正开跑」的参数，然后停在 stdin 上等 stop。
+func jobCore(t *testing.T) string {
+	t.Helper()
+	dir := t.TempDir()
+	path := filepath.Join(dir, "magic-agent")
+	script := `#!/bin/sh
+case "$*" in
+  *--contract*)
+    echo '{"contractVersion":2,"features":["feature.session.events","feature.session.control"],"engines":[{"engine":"claude","ok":true,"capabilities":["session.stream"]}]}'
+    exit 0
+    ;;
+  *--engines*)
+    echo '[{"engine":"claude","ok":true,"capabilities":["session.stream"]}]'
+    exit 0
+    ;;
+  *--sessions*)
+    echo '[]'
+    exit 0
+    ;;
+esac
+if [ -n "$JOB_TEST_LOG" ]; then
+  printf '%s\n' "$*" >> "$JOB_TEST_LOG"
+fi
+echo '{"v":1,"seq":1,"type":"ready","engine":"claude"}'
+echo '{"v":1,"seq":2,"type":"text","text":"ok"}'
+while IFS= read -r line; do
+  case "$line" in
+    *'"stop"'*) echo '{"v":1,"seq":3,"type":"result"}'; exit 0 ;;
+  esac
+done
+`
+	if err := os.WriteFile(path, []byte(script), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
+
+func jobTestService(t *testing.T, core string) (*Service, string) {
+	t.Helper()
+	dir := t.TempDir()
+	logPath := filepath.Join(dir, "runs.log")
+	t.Setenv("MAGIC_CLIENT_JOBS_DIR", filepath.Join(dir, "jobs"))
+	t.Setenv("MAGIC_CLIENT_MAX_RUNNING", "8")
+	t.Setenv("JOB_TEST_LOG", logPath)
+	svc, err := New(Options{MagicAgent: core, Profile: DefaultProfile(), Token: "tok"})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	/* 收尾：先停调度循环并给假 core 发 stop，等后台把最后一笔状态写完，
+	   再让 t.TempDir 去删目录（否则会和作业落盘抢文件）。 */
+	t.Cleanup(func() {
+		svc.jobs.close()
+		time.Sleep(300 * time.Millisecond)
+	})
+	return svc, logPath
+}
+
+func postJob(t *testing.T, base string, req map[string]any) *Job {
+	t.Helper()
+	b, _ := json.Marshal(req)
+	r, _ := http.NewRequest(http.MethodPost, base+"/desk/jobs", bytes.NewReader(b))
+	r.Header.Set("X-Magic-Token", "tok")
+	resp, err := http.DefaultClient.Do(r)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusAccepted {
+		msg, _ := io.ReadAll(resp.Body)
+		t.Fatalf("POST /desk/jobs 应 2xx，实际 %d（%s）", resp.StatusCode, msg)
+	}
+	var out struct {
+		Job *Job `json:"job"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil || out.Job == nil {
+		t.Fatalf("作业响应不合法：%v", err)
+	}
+	return out.Job
+}
+
+func getJob(t *testing.T, base, id string) *Job {
+	t.Helper()
+	r, _ := http.NewRequest(http.MethodGet, base+"/desk/jobs/"+id, nil)
+	r.Header.Set("X-Magic-Token", "tok")
+	resp, err := http.DefaultClient.Do(r)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	var j Job
+	if err := json.NewDecoder(resp.Body).Decode(&j); err != nil {
+		t.Fatalf("GET /desk/jobs/{id} 解析失败：%v", err)
+	}
+	return &j
+}
+
+func waitJob(t *testing.T, base, id string, want func(*Job) bool, timeout time.Duration) *Job {
+	t.Helper()
+	deadline := time.Now().Add(timeout)
+	var last *Job
+	for time.Now().Before(deadline) {
+		last = getJob(t, base, id)
+		if want(last) {
+			return last
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+	t.Fatalf("作业 %s 未在 %s 内达到期望状态，最后：%+v", id, timeout, last)
+	return nil
+}
+
+func readRuns(t *testing.T, path string) []string {
+	t.Helper()
+	b, err := os.ReadFile(path)
+	if err != nil {
+		return nil
+	}
+	var out []string
+	for _, ln := range strings.Split(strings.TrimSpace(string(b)), "\n") {
+		if strings.TrimSpace(ln) != "" {
+			out = append(out, ln)
+		}
+	}
+	return out
+}
+
+func TestJobsSerialPerWorkspace(t *testing.T) {
+	svc, runs := jobTestService(t, jobCore(t))
+	srv := httptest.NewServer(svc.Handler())
+	defer srv.Close()
+	ws := t.TempDir()
+
+	j1 := postJob(t, srv.URL, map[string]any{"engine": "claude", "prompt": "一", "workspace": ws, "serial": true, "request_id": "r1"})
+	if j1.State != JobQueued {
+		t.Errorf("刚提交应是 queued，实际 %s", j1.State)
+	}
+	waitJob(t, srv.URL, j1.ID, func(j *Job) bool { return j.State == JobRunning }, 5*time.Second)
+
+	j2 := postJob(t, srv.URL, map[string]any{"engine": "claude", "prompt": "二", "workspace": ws, "serial": true, "request_id": "r2"})
+	time.Sleep(600 * time.Millisecond) // 给调度器足够时间：它**不该**开第二条
+	j2 = getJob(t, srv.URL, j2.ID)
+	if j2.State != JobQueued {
+		t.Fatalf("同 workspace 第二条必须排队，实际 %s", j2.State)
+	}
+	if got := len(readRuns(t, runs)); got != 1 {
+		t.Fatalf("同 workspace 只应有 1 次真正开跑，实际 %d：%v", got, readRuns(t, runs))
+	}
+
+	// 取消排队的第二条：它绝不能之后偷偷开跑。
+	cr, _ := http.NewRequest(http.MethodPost, srv.URL+"/desk/jobs/"+j2.ID+"/cancel", nil)
+	cr.Header.Set("X-Magic-Token", "tok")
+	resp, err := http.DefaultClient.Do(cr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp.Body.Close()
+	j2 = waitJob(t, srv.URL, j2.ID, func(j *Job) bool { return j.State == JobCancelled }, 3*time.Second)
+	if j2.State != JobCancelled {
+		t.Fatalf("取消失败：%+v", j2)
+	}
+
+	// 停掉第一条，槽位释放。
+	cr2, _ := http.NewRequest(http.MethodPost, srv.URL+"/desk/jobs/"+j1.ID+"/cancel", nil)
+	cr2.Header.Set("X-Magic-Token", "tok")
+	if resp, err := http.DefaultClient.Do(cr2); err == nil {
+		resp.Body.Close()
+	}
+	waitJob(t, srv.URL, j1.ID, func(j *Job) bool { return j.terminal() }, 5*time.Second)
+	time.Sleep(300 * time.Millisecond)
+	if got := len(readRuns(t, runs)); got != 1 {
+		t.Fatalf("被取消的排队条目不应开跑，实际开跑 %d 次：%v", got, readRuns(t, runs))
+	}
+}
+
+func TestJobsParallelAcrossWorkspaces(t *testing.T) {
+	svc, runs := jobTestService(t, jobCore(t))
+	srv := httptest.NewServer(svc.Handler())
+	defer srv.Close()
+
+	wsA, wsB := t.TempDir(), t.TempDir()
+	a := postJob(t, srv.URL, map[string]any{"engine": "claude", "prompt": "a", "workspace": wsA, "serial": true, "request_id": "pa"})
+	b := postJob(t, srv.URL, map[string]any{"engine": "claude", "prompt": "b", "workspace": wsB, "serial": true, "request_id": "pb"})
+	waitJob(t, srv.URL, a.ID, func(j *Job) bool { return j.State == JobRunning }, 5*time.Second)
+	waitJob(t, srv.URL, b.ID, func(j *Job) bool { return j.State == JobRunning }, 5*time.Second)
+	if got := len(readRuns(t, runs)); got != 2 {
+		t.Fatalf("不同 workspace 应并行开跑（2 次），实际 %d：%v", got, readRuns(t, runs))
+	}
+	for _, id := range []string{a.ID, b.ID} {
+		r, _ := http.NewRequest(http.MethodPost, srv.URL+"/desk/jobs/"+id+"/cancel", nil)
+		r.Header.Set("X-Magic-Token", "tok")
+		if resp, err := http.DefaultClient.Do(r); err == nil {
+			resp.Body.Close()
+		}
+	}
+}
+
+func TestJobsIdempotentRequestID(t *testing.T) {
+	svc, runs := jobTestService(t, jobCore(t))
+	srv := httptest.NewServer(svc.Handler())
+	defer srv.Close()
+	ws := t.TempDir()
+	body := map[string]any{"engine": "claude", "prompt": "只跑一次", "workspace": ws, "serial": false, "request_id": "same-id"}
+
+	j1 := postJob(t, srv.URL, body)
+	j2 := postJob(t, srv.URL, body)
+	if j1.ID != j2.ID {
+		t.Fatalf("同一 request_id 应返回同一个作业：%s vs %s", j1.ID, j2.ID)
+	}
+	waitJob(t, srv.URL, j1.ID, func(j *Job) bool { return j.State == JobRunning }, 5*time.Second)
+	time.Sleep(400 * time.Millisecond)
+	if got := len(readRuns(t, runs)); got != 1 {
+		t.Fatalf("幂等失败：同一 request_id 开跑了 %d 次", got)
+	}
+	r, _ := http.NewRequest(http.MethodPost, srv.URL+"/desk/jobs/"+j1.ID+"/cancel", nil)
+	r.Header.Set("X-Magic-Token", "tok")
+	if resp, err := http.DefaultClient.Do(r); err == nil {
+		resp.Body.Close()
+	}
+}
+
+func TestJobQueueRecoversAfterRestart(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv("MAGIC_CLIENT_JOBS_DIR", dir)
+	now := time.Now()
+	running := Job{
+		ID: "job-running", Workspace: "/tmp/ws", Engine: "claude", Prompt: "旧的",
+		State: JobRunning, Serial: true, CreatedAt: now.Add(-time.Minute), UpdatedAt: now.Add(-time.Minute),
+	}
+	queued := Job{
+		ID: "job-queued", RequestID: "req-old", Workspace: "/tmp/ws", Engine: "claude", Prompt: "排队的",
+		State: JobQueued, Serial: true, CreatedAt: now, UpdatedAt: now, ExpiresAt: now.Add(time.Hour),
+	}
+	for _, j := range []Job{running, queued} {
+		b, _ := json.Marshal(j)
+		if err := os.WriteFile(filepath.Join(dir, j.ID+".json"), b, 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	svc := &Service{opts: Options{Profile: DefaultProfile()}, log: log.New(io.Discard, "", 0), runs: map[string]*askRun{}}
+	q := newJobQueue(svc)
+	defer q.close()
+	gotRun := q.get("job-running")
+	if gotRun == nil || gotRun.State != JobFailed {
+		t.Fatalf("running 残留应标失败，实际 %+v", gotRun)
+	}
+	if !strings.Contains(gotRun.Error, "重启") {
+		t.Errorf("失败原因应说明重启，实际 %q", gotRun.Error)
+	}
+	gotQueued := q.get("job-queued")
+	if gotQueued == nil || gotQueued.State != JobQueued {
+		t.Fatalf("带 request_id 的 queued 应保留，实际 %+v", gotQueued)
+	}
+}
+
+func TestAskIdempotentRequestID(t *testing.T) {
+	svc, runs := jobTestService(t, jobCore(t))
+	srv := httptest.NewServer(svc.Handler())
+	defer srv.Close()
+
+	req := askRequest{Engine: "claude", Prompt: "重复提交", RequestID: "dup-ask"}
+	s1 := openSSE(t, srv.URL, "tok", req)
+	defer s1.close()
+	ev1 := s1.next(t)
+	id1, _ := ev1["id"].(string)
+
+	/* 第二次提交（模拟断线后重连 / 另一个标签页）：应接回同一轮，而不是再起一个 core。 */
+	s2 := openSSE(t, srv.URL, "tok", req)
+	defer s2.close()
+	ev2 := s2.next(t)
+	id2, _ := ev2["id"].(string)
+
+	if id1 == "" || id1 != id2 {
+		t.Fatalf("同一 request_id 的两条 /desk/ask 应接回同一轮：%q vs %q", id1, id2)
+	}
+	time.Sleep(400 * time.Millisecond)
+	if got := len(readRuns(t, runs)); got != 1 {
+		t.Fatalf("同一 request_id 只应开跑一次，实际 %d", got)
+	}
+}
+
+func TestJobsListAndSnapshot(t *testing.T) {
+	svc, _ := jobTestService(t, jobCore(t))
+	srv := httptest.NewServer(svc.Handler())
+	defer srv.Close()
+	ws := t.TempDir()
+	j := postJob(t, srv.URL, map[string]any{"engine": "claude", "prompt": "列表", "workspace": ws, "serial": false, "request_id": "list-1"})
+
+	// 列表里能看到它（带位置字段）。
+	r, _ := http.NewRequest(http.MethodGet, srv.URL+"/desk/jobs?workspace="+ws, nil)
+	r.Header.Set("X-Magic-Token", "tok")
+	resp, err := http.DefaultClient.Do(r)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	var out struct {
+		Jobs []*Job `json:"jobs"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+		t.Fatal(err)
+	}
+	found := false
+	for _, it := range out.Jobs {
+		if it.ID == j.ID {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatalf("列表里应能看到刚提交的作业：%+v", out.Jobs)
+	}
+
+	// 事件快照：开跑后应能拿到 ready/text。
+	waitJob(t, srv.URL, j.ID, func(x *Job) bool { return x.State == JobRunning }, 5*time.Second)
+	deadline := time.Now().Add(3 * time.Second)
+	ok := false
+	for time.Now().Before(deadline) {
+		er, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("%s/desk/jobs/%s/events?after=0", srv.URL, j.ID), nil)
+		er.Header.Set("X-Magic-Token", "tok")
+		eresp, err := http.DefaultClient.Do(er)
+		if err != nil {
+			t.Fatal(err)
+		}
+		var snap struct {
+			Events []map[string]any `json:"events"`
+		}
+		_ = json.NewDecoder(eresp.Body).Decode(&snap)
+		eresp.Body.Close()
+		for _, ev := range snap.Events {
+			if ev["type"] == "ready" {
+				ok = true
+			}
+		}
+		if ok {
+			break
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+	if !ok {
+		t.Fatal("作业事件快照里应能看到 core 的 ready")
+	}
+	r2, _ := http.NewRequest(http.MethodPost, srv.URL+"/desk/jobs/"+j.ID+"/cancel", nil)
+	r2.Header.Set("X-Magic-Token", "tok")
+	if resp, err := http.DefaultClient.Do(r2); err == nil {
+		resp.Body.Close()
+	}
+}