218 lines
7.2 KiB
Go
218 lines
7.2 KiB
Go
package app
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/hjbdev/patterm/internal/mcp"
|
|
)
|
|
|
|
// mkChild builds a Child without starting a PTY. Use sparingly — the
|
|
// resulting child has no emulator / ring buffer / status pointer set
|
|
// the way newChild would.
|
|
func mkChild(id, name, parent string) *Child {
|
|
return &Child{ID: id, Name: name, ParentID: parent}
|
|
}
|
|
|
|
func TestClassifySendMessageOrchestratorToChild(t *testing.T) {
|
|
parent := mkChild("p_aaa", "claude-1", "")
|
|
child := mkChild("p_bbb", "codex-1", "p_aaa")
|
|
|
|
line, err := classifySendMessage(parent, child, parent.ID, "hi child")
|
|
if err != nil {
|
|
t.Fatalf("expected success, got %v", err)
|
|
}
|
|
if !strings.HasPrefix(line, "[orchestrator] hi child") {
|
|
t.Fatalf("parent→child should tag [orchestrator], got %q", line)
|
|
}
|
|
}
|
|
|
|
func TestClassifySendMessageChildToParent(t *testing.T) {
|
|
parent := mkChild("p_aaa", "claude-1", "")
|
|
child := mkChild("p_bbb", "codex-1", "p_aaa")
|
|
|
|
line, err := classifySendMessage(child, parent, child.ID, "status update")
|
|
if err != nil {
|
|
t.Fatalf("expected success, got %v", err)
|
|
}
|
|
if !strings.Contains(line, "[sub-agent:codex-1]") {
|
|
t.Fatalf("child→parent should tag [sub-agent:<name>], got %q", line)
|
|
}
|
|
}
|
|
|
|
func TestClassifySendMessageSiblingRejected(t *testing.T) {
|
|
parent := mkChild("p_aaa", "claude-1", "")
|
|
sibA := mkChild("p_bbb", "codex-1", "p_aaa")
|
|
sibB := mkChild("p_ccc", "codex-2", "p_aaa")
|
|
_ = parent
|
|
|
|
_, err := classifySendMessage(sibA, sibB, sibA.ID, "hey")
|
|
if err == nil {
|
|
t.Fatalf("sibling send_message should fail with not_related")
|
|
}
|
|
if !strings.Contains(err.Error(), "neither parent nor child") {
|
|
t.Fatalf("error should mention sibling routing rule, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestClassifySendMessageUnrelatedRejected(t *testing.T) {
|
|
// Two unrelated top-level processes — they have no shared lineage.
|
|
a := mkChild("p_aaa", "claude-1", "")
|
|
b := mkChild("p_bbb", "codex-1", "")
|
|
|
|
_, err := classifySendMessage(a, b, a.ID, "hi")
|
|
if err == nil {
|
|
t.Fatalf("unrelated top-level send_message should fail")
|
|
}
|
|
}
|
|
|
|
func TestClassifySendMessageCannotSendToSelf(t *testing.T) {
|
|
c := mkChild("p_aaa", "claude-1", "")
|
|
_, err := classifySendMessage(c, c, c.ID, "talking to myself")
|
|
if err == nil {
|
|
t.Fatalf("self-send should fail")
|
|
}
|
|
}
|
|
|
|
func TestClassifySendMessageNilCallerAcceptsTopLevel(t *testing.T) {
|
|
// Caller arrived over an MCP connection without a resolved patterm
|
|
// identity (top-level tool client). Target is top-level; should
|
|
// land as [orchestrator].
|
|
target := mkChild("p_aaa", "claude-1", "")
|
|
line, err := classifySendMessage(nil, target, "" /* unknown caller id */, "go")
|
|
if err != nil {
|
|
t.Fatalf("expected success for nil-caller → top-level target, got %v", err)
|
|
}
|
|
if !strings.HasPrefix(line, "[orchestrator] go") {
|
|
t.Fatalf("expected [orchestrator] tag, got %q", line)
|
|
}
|
|
}
|
|
|
|
func TestClassifySendMessageNilCallerRejectsNonTopLevelTarget(t *testing.T) {
|
|
parent := mkChild("p_aaa", "claude-1", "")
|
|
child := mkChild("p_bbb", "codex-1", "p_aaa")
|
|
_ = parent
|
|
|
|
_, err := classifySendMessage(nil, child, "", "hi")
|
|
if err == nil {
|
|
t.Fatalf("nil caller → non-top-level should fail")
|
|
}
|
|
}
|
|
|
|
func TestWrapSubAgentPromptPrependsSystemBlockWhenParented(t *testing.T) {
|
|
out := wrapSubAgentPrompt("ship feature X", true)
|
|
if !strings.HasPrefix(out, "[system:") {
|
|
t.Fatalf("expected prepended [system: …] block, got %q", out)
|
|
}
|
|
if !strings.Contains(out, "send_message") {
|
|
t.Fatalf("wrapper should mention send_message reporting, got %q", out)
|
|
}
|
|
if !strings.Contains(out, "close_process") || !strings.Contains(out, "scratchpad") {
|
|
t.Fatalf("wrapper should mention cleanup (close_process / scratchpad), got %q", out)
|
|
}
|
|
if !strings.HasSuffix(out, "ship feature X") {
|
|
t.Fatalf("wrapper should keep original instructions at the tail, got %q", out)
|
|
}
|
|
if strings.Contains(out, "\n") || strings.Contains(out, "\r") {
|
|
t.Fatalf("wrapper must be single-line (writeInput splits CR/LF), got %q", out)
|
|
}
|
|
}
|
|
|
|
func TestWrapSubAgentPromptPassthroughWhenNoParent(t *testing.T) {
|
|
out := wrapSubAgentPrompt("hello", false)
|
|
if out != "hello" {
|
|
t.Fatalf("expected passthrough for top-level spawn, got %q", out)
|
|
}
|
|
}
|
|
|
|
func TestWrapSubAgentPromptEmptyStaysEmpty(t *testing.T) {
|
|
// Empty instructions mean "no inject" upstream; we must not synthesize
|
|
// content here or LaunchAgent would type the system block into an
|
|
// otherwise-idle agent.
|
|
if out := wrapSubAgentPrompt("", true); out != "" {
|
|
t.Fatalf("empty instructions should stay empty, got %q", out)
|
|
}
|
|
}
|
|
|
|
func TestHelpLifecycleTopicCoversCleanup(t *testing.T) {
|
|
resp := helpFor("lifecycle")
|
|
if resp.Topic != "lifecycle" {
|
|
t.Fatalf("expected topic=lifecycle, got %q", resp.Topic)
|
|
}
|
|
for _, kw := range []string{"close_process", "spawn", "sub-agent"} {
|
|
if !strings.Contains(resp.Content, kw) {
|
|
t.Fatalf("lifecycle help should mention %q, got %q", kw, resp.Content)
|
|
}
|
|
}
|
|
if !containsString(resp.RelatedTools, "close_process") {
|
|
t.Fatalf("lifecycle help should list close_process in related tools, got %v", resp.RelatedTools)
|
|
}
|
|
}
|
|
|
|
func TestHelpTopicsIndexListsLifecycle(t *testing.T) {
|
|
resp := helpFor("topics")
|
|
if !strings.Contains(resp.Content, "lifecycle") {
|
|
t.Fatalf("topics index should advertise the lifecycle topic, got %q", resp.Content)
|
|
}
|
|
}
|
|
|
|
func TestHelpSpawningPointsAtLifecycle(t *testing.T) {
|
|
resp := helpFor("spawning")
|
|
if !strings.Contains(resp.Content, "lifecycle") {
|
|
t.Fatalf("spawning help should reference the lifecycle topic, got %q", resp.Content)
|
|
}
|
|
if !containsString(resp.RelatedTools, "close_process") {
|
|
t.Fatalf("spawning help should include close_process in related tools, got %v", resp.RelatedTools)
|
|
}
|
|
}
|
|
|
|
// TestAvailableToolsAdvertisesAllTimerTools makes sure orchestrators
|
|
// and sub-agents discover the full timer surface via whoami — not just
|
|
// timer_wait. Otherwise agents using whoami for orientation would never
|
|
// learn about timer_set, timer_fire_when_idle_*, timer_pause/resume,
|
|
// timer_cancel, and timer_list.
|
|
func TestAvailableToolsAdvertisesAllTimerTools(t *testing.T) {
|
|
want := []string{
|
|
"timer_wait", "timer_set",
|
|
"timer_fire_when_idle_any", "timer_fire_when_idle_all",
|
|
"timer_cancel", "timer_pause", "timer_resume", "timer_list",
|
|
}
|
|
for _, role := range []mcp.CallerRole{mcp.RoleOrchestrator, mcp.RoleSubAgent} {
|
|
tools := availableToolsForRole(role)
|
|
for _, w := range want {
|
|
if !containsString(tools, w) {
|
|
t.Fatalf("role %q missing %q in available tools: %v", role, w, tools)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestHelpTimersDocumentsAllTools mirrors the whoami check for the
|
|
// help("timers") topic — the related-tools list must enumerate every
|
|
// timer_* tool so callers reading help can dispatch them.
|
|
func TestHelpTimersDocumentsAllTools(t *testing.T) {
|
|
resp := helpFor("timers")
|
|
if resp.Topic != "timers" {
|
|
t.Fatalf("topic: %q", resp.Topic)
|
|
}
|
|
want := []string{
|
|
"timer_wait", "timer_set",
|
|
"timer_fire_when_idle_any", "timer_fire_when_idle_all",
|
|
"timer_cancel", "timer_pause", "timer_resume", "timer_list",
|
|
}
|
|
for _, w := range want {
|
|
if !containsString(resp.RelatedTools, w) {
|
|
t.Fatalf("timers help missing %q in related tools: %v", w, resp.RelatedTools)
|
|
}
|
|
}
|
|
}
|
|
|
|
func containsString(haystack []string, needle string) bool {
|
|
for _, s := range haystack {
|
|
if s == needle {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|