151 lines
3.5 KiB
Go
151 lines
3.5 KiB
Go
package inbox
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"path/filepath"
|
|
"testing"
|
|
)
|
|
|
|
func TestInboxLifecycle(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
dbPath := filepath.Join(t.TempDir(), "coord.db")
|
|
|
|
initOut := runInboxCommand(t, "--db", dbPath, "--json", "init")
|
|
var initResp map[string]any
|
|
mustDecodeJSON(t, initOut, &initResp)
|
|
if initResp["ok"] != true {
|
|
t.Fatalf("expected init ok=true, got %#v", initResp)
|
|
}
|
|
|
|
sendOut := runInboxCommand(
|
|
t,
|
|
"--db", dbPath,
|
|
"--json",
|
|
"send",
|
|
"--from", "leader",
|
|
"--to", "worker-a",
|
|
"--subject", "Implement feature X",
|
|
"--summary", "Add retry policy",
|
|
"--body", "Implement retry handling for the HTTP client.",
|
|
"--run", "run_blog_001",
|
|
"--task", "T1",
|
|
)
|
|
|
|
var sendResp map[string]any
|
|
mustDecodeJSON(t, sendOut, &sendResp)
|
|
threadID := nestedString(t, sendResp, "data", "thread", "thread_id")
|
|
threadStatus := nestedString(t, sendResp, "data", "thread", "status")
|
|
if threadStatus != "pending" {
|
|
t.Fatalf("expected pending thread, got %q", threadStatus)
|
|
}
|
|
|
|
fetchOut := runInboxCommand(
|
|
t,
|
|
"--db", dbPath,
|
|
"--json",
|
|
"fetch",
|
|
"--agent", "worker-a",
|
|
"--status", "pending",
|
|
)
|
|
|
|
var fetchResp map[string]any
|
|
mustDecodeJSON(t, fetchOut, &fetchResp)
|
|
threadsValue := nestedValue(t, fetchResp, "data", "threads")
|
|
threads, ok := threadsValue.([]any)
|
|
if !ok || len(threads) != 1 {
|
|
t.Fatalf("expected one fetched thread, got %#v", threadsValue)
|
|
}
|
|
|
|
claimOut := runInboxCommand(
|
|
t,
|
|
"--db", dbPath,
|
|
"--json",
|
|
"claim",
|
|
"--agent", "worker-a",
|
|
"--thread", threadID,
|
|
"--lease-seconds", "300",
|
|
)
|
|
|
|
var claimResp map[string]any
|
|
mustDecodeJSON(t, claimOut, &claimResp)
|
|
claimedStatus := nestedString(t, claimResp, "data", "thread", "status")
|
|
if claimedStatus != "claimed" {
|
|
t.Fatalf("expected claimed thread, got %q", claimedStatus)
|
|
}
|
|
|
|
showOut := runInboxCommand(
|
|
t,
|
|
"--db", dbPath,
|
|
"--json",
|
|
"show",
|
|
"--thread", threadID,
|
|
)
|
|
|
|
var showResp map[string]any
|
|
mustDecodeJSON(t, showOut, &showResp)
|
|
showStatus := nestedString(t, showResp, "data", "thread", "status")
|
|
if showStatus != "claimed" {
|
|
t.Fatalf("expected show status claimed, got %q", showStatus)
|
|
}
|
|
messagesValue := nestedValue(t, showResp, "data", "messages")
|
|
messages, ok := messagesValue.([]any)
|
|
if !ok || len(messages) != 2 {
|
|
t.Fatalf("expected two messages in thread history, got %#v", messagesValue)
|
|
}
|
|
}
|
|
|
|
func runInboxCommand(t *testing.T, args ...string) string {
|
|
t.Helper()
|
|
|
|
cmd := NewRootCmd()
|
|
var stdout bytes.Buffer
|
|
var stderr bytes.Buffer
|
|
cmd.SetOut(&stdout)
|
|
cmd.SetErr(&stderr)
|
|
cmd.SetArgs(args)
|
|
|
|
if err := cmd.Execute(); err != nil {
|
|
t.Fatalf("execute inbox command %v: %v\nstderr:\n%s", args, err, stderr.String())
|
|
}
|
|
|
|
return stdout.String()
|
|
}
|
|
|
|
func mustDecodeJSON(t *testing.T, raw string, target any) {
|
|
t.Helper()
|
|
|
|
if err := json.Unmarshal([]byte(raw), target); err != nil {
|
|
t.Fatalf("decode json %q: %v", raw, err)
|
|
}
|
|
}
|
|
|
|
func nestedString(t *testing.T, value map[string]any, keys ...string) string {
|
|
t.Helper()
|
|
|
|
current := nestedValue(t, value, keys...)
|
|
str, ok := current.(string)
|
|
if !ok {
|
|
t.Fatalf("expected string at %v, got %#v", keys, current)
|
|
}
|
|
return str
|
|
}
|
|
|
|
func nestedValue(t *testing.T, value map[string]any, keys ...string) any {
|
|
t.Helper()
|
|
|
|
var current any = value
|
|
for _, key := range keys {
|
|
obj, ok := current.(map[string]any)
|
|
if !ok {
|
|
t.Fatalf("expected object at %q in %v, got %#v", key, keys, current)
|
|
}
|
|
current, ok = obj[key]
|
|
if !ok {
|
|
t.Fatalf("missing key %q in %v", key, keys)
|
|
}
|
|
}
|
|
return current
|
|
}
|