macro-agent 0.1.0 → 0.1.2

package/src/task/backend/sudocode/__tests__/e2e/server-client.e2e.test.ts

@@ -1,680 +0,0 @@
-/**
- * E2E Tests for ServerClient
- *
- * These tests automatically start a sudocode server, run tests against it,
- * and then shut it down. They are NOT run during regular test execution.
- *
- * Run them explicitly with:
- *
- *   npm run test:e2e
- *
- * Or directly:
- *
- *   npm test -- src/task/backend/sudocode/__tests__/e2e/
- *
- * The tests will:
- *   1. Create a temporary project directory
- *   2. Initialize sudocode in that directory
- *   3. Start a sudocode server
- *   4. Run all tests against the server
- *   5. Shut down the server and clean up
- */
-
-import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from "vitest";
-import { spawn, execSync, ChildProcess } from "child_process";
-import { mkdtempSync, rmSync, existsSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import { ServerClient } from "../../server-client.js";
-import type { Issue, Spec } from "../../client.js";
-
-// Configuration
-const TEST_PORT = 13579; // Use a non-standard port to avoid conflicts
-const SERVER_URL = `http://localhost:${TEST_PORT}`;
-const WS_URL = `ws://localhost:${TEST_PORT}/ws`;
-const TEST_TIMEOUT = 15000;
-const SERVER_STARTUP_TIMEOUT = 10000;
-
-// Global state
-let serverProcess: ChildProcess | null = null;
-let projectDir: string | null = null;
-let projectId: string | null = null;
-
-// Track created entities for cleanup
-const createdIssueIds: string[] = [];
-const createdSpecIds: string[] = [];
-
-/**
- * Wait for the server to be ready
- */
-async function waitForServer(
-  url: string,
-  timeout: number = SERVER_STARTUP_TIMEOUT
-): Promise<boolean> {
-  const startTime = Date.now();
-
-  while (Date.now() - startTime < timeout) {
-    try {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 1000);
-
-      const response = await fetch(`${url}/health`, {
-        signal: controller.signal,
-      });
-
-      clearTimeout(timeoutId);
-
-      if (response.ok) {
-        return true;
-      }
-    } catch {
-      // Server not ready yet, wait and retry
-    }
-
-    await new Promise((r) => setTimeout(r, 200));
-  }
-
-  return false;
-}
-
-/**
- * Normalize path to handle macOS symlinks (/var -> /private/var)
- */
-function normalizePath(p: string): string {
-  // On macOS, /var, /tmp, /etc are symlinks to /private/...
-  if (p.startsWith("/private/")) {
-    return p.substring("/private".length);
-  }
-  return p;
-}
-
-/**
- * Get the project ID for our test project from the server (with retry)
- */
-async function getProjectId(
-  serverUrl: string,
-  projectPath: string,
-  maxRetries: number = 10
-): Promise<string> {
-  const normalizedPath = normalizePath(projectPath);
-
-  for (let attempt = 0; attempt < maxRetries; attempt++) {
-    try {
-      const response = await fetch(`${serverUrl}/api/projects`);
-      const result = await response.json();
-
-      if (!result.success || !Array.isArray(result.data)) {
-        if (process.env.DEBUG_E2E) {
-          console.log(`[getProjectId] API returned: ${JSON.stringify(result)}`);
-        }
-        await new Promise((r) => setTimeout(r, 500));
-        continue;
-      }
-
-      // Find project matching our path (handle symlinks)
-      const project = result.data.find((p: { path: string; id: string }) => {
-        const normalizedProjectPath = normalizePath(p.path);
-        return normalizedProjectPath === normalizedPath;
-      });
-
-      if (project) {
-        return project.id;
-      }
-
-      if (process.env.DEBUG_E2E) {
-        console.log(`[getProjectId] Looking for: ${normalizedPath}`);
-        console.log(`[getProjectId] Available projects: ${result.data.map((p: { path: string }) => normalizePath(p.path)).join(", ")}`);
-      }
-    } catch (err) {
-      if (process.env.DEBUG_E2E) {
-        console.log(`[getProjectId] Error: ${err}`);
-      }
-    }
-
-    // Wait before retry
-    await new Promise((r) => setTimeout(r, 500));
-  }
-
-  throw new Error(`Project not found for path: ${projectPath} after ${maxRetries} retries`);
-}
-
-/**
- * Start the sudocode server
- */
-async function startServer(): Promise<void> {
-  // Kill any stale processes on the test port
-  try {
-    execSync(`lsof -t -i :${TEST_PORT} | xargs kill -9 2>/dev/null || true`, {
-      stdio: "ignore",
-    });
-  } catch {
-    // Ignore errors - no stale process to kill
-  }
-
-  // Create temporary project directory
-  projectDir = mkdtempSync(join(tmpdir(), "sudocode-e2e-"));
-
-  // Initialize sudocode in the project directory
-  await new Promise<void>((resolve, reject) => {
-    const initProcess = spawn("npx", ["sudocode", "init"], {
-      cwd: projectDir!,
-      stdio: "pipe",
-    });
-
-    initProcess.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`sudocode init failed with code ${code}`));
-      }
-    });
-
-    initProcess.on("error", reject);
-  });
-
-  // Start the server
-  serverProcess = spawn(
-    "npx",
-    ["sudocode", "server", "-p", String(TEST_PORT)],
-    {
-      cwd: projectDir,
-      stdio: "pipe",
-      env: { ...process.env, FORCE_COLOR: "0" },
-    }
-  );
-
-  // Log server output for debugging
-  serverProcess.stdout?.on("data", (data) => {
-    if (process.env.DEBUG_E2E) {
-      console.log(`[server stdout] ${data}`);
-    }
-  });
-
-  serverProcess.stderr?.on("data", (data) => {
-    if (process.env.DEBUG_E2E) {
-      console.error(`[server stderr] ${data}`);
-    }
-  });
-
-  serverProcess.on("error", (err) => {
-    console.error("Server process error:", err);
-  });
-
-  // Wait for server to be ready
-  const ready = await waitForServer(SERVER_URL);
-  if (!ready) {
-    throw new Error(
-      `Server failed to start within ${SERVER_STARTUP_TIMEOUT}ms`
-    );
-  }
-
-  // Get the actual project ID assigned by the server
-  projectId = await getProjectId(SERVER_URL, projectDir);
-}
-
-/**
- * Stop the sudocode server
- */
-async function stopServer(): Promise<void> {
-  if (serverProcess) {
-    // Send SIGTERM
-    serverProcess.kill("SIGTERM");
-
-    // Wait for process to exit
-    await new Promise<void>((resolve) => {
-      const timeout = setTimeout(() => {
-        // Force kill if it doesn't exit gracefully
-        serverProcess?.kill("SIGKILL");
-        resolve();
-      }, 5000);
-
-      serverProcess!.on("close", () => {
-        clearTimeout(timeout);
-        resolve();
-      });
-    });
-
-    serverProcess = null;
-  }
-
-  // Clean up project directory
-  if (projectDir && existsSync(projectDir)) {
-    rmSync(projectDir, { recursive: true, force: true });
-    projectDir = null;
-  }
-}
-
-/**
- * Create a test issue via the API
- */
-async function createTestIssue(
-  title: string,
-  content?: string
-): Promise<Issue> {
-  const response = await fetch(`${SERVER_URL}/api/issues`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "X-Project-ID": projectId!,
-    },
-    body: JSON.stringify({
-      title,
-      content: content ?? `Test content for ${title}`,
-      status: "open",
-      priority: 2,
-    }),
-  });
-
-  const result = await response.json();
-  if (!result.success) {
-    throw new Error(`Failed to create issue: ${result.message}`);
-  }
-
-  createdIssueIds.push(result.data.id);
-  return result.data;
-}
-
-/**
- * Create a test spec via the API
- */
-async function createTestSpec(title: string, content?: string): Promise<Spec> {
-  const response = await fetch(`${SERVER_URL}/api/specs`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "X-Project-ID": projectId!,
-    },
-    body: JSON.stringify({
-      title,
-      file_path: `specs/${title.toLowerCase().replace(/\s+/g, "-")}.md`,
-      content: content ?? `Test spec content for ${title}`,
-      priority: 2,
-    }),
-  });
-
-  const result = await response.json();
-  if (!result.success) {
-    throw new Error(`Failed to create spec: ${result.message}`);
-  }
-
-  createdSpecIds.push(result.data.id);
-  return result.data;
-}
-
-describe("ServerClient E2E", () => {
-  let client: ServerClient;
-
-  beforeAll(async () => {
-    console.log("\n🚀 Starting sudocode server for E2E tests...");
-    await startServer();
-    console.log(`✅ Server ready at ${SERVER_URL}\n`);
-  }, SERVER_STARTUP_TIMEOUT + 5000);
-
-  afterAll(async () => {
-    console.log("\n🛑 Shutting down sudocode server...");
-    await stopServer();
-    console.log("✅ Cleanup complete\n");
-  }, 10000);
-
-  beforeEach(async () => {
-    client = new ServerClient({
-      serverUrl: SERVER_URL,
-      wsUrl: WS_URL,
-      projectId: projectId!,
-    });
-
-    // Wait for WebSocket connection
-    await new Promise<void>((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error("WebSocket connection timeout"));
-      }, 5000);
-
-      const checkReady = () => {
-        if (client.isReady()) {
-          clearTimeout(timeout);
-          resolve();
-        } else {
-          setTimeout(checkReady, 50);
-        }
-      };
-      checkReady();
-    });
-  });
-
-  afterEach(() => {
-    if (client) {
-      client.close();
-    }
-  });
-
-  describe("Connection", () => {
-    it(
-      "should connect to the server via WebSocket",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        expect(client.isReady()).toBe(true);
-      }
-    );
-  });
-
-  describe("Issue Operations", () => {
-    it(
-      "should get an issue by ID",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        const created = await createTestIssue("E2E Test Issue - Get");
-
-        const issue = await client.getIssue(created.id);
-
-        expect(issue).not.toBeNull();
-        expect(issue!.id).toBe(created.id);
-        expect(issue!.title).toBe("E2E Test Issue - Get");
-      }
-    );
-
-    it(
-      "should return null for non-existent issue",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        const issue = await client.getIssue("i-nonexistent-12345");
-        expect(issue).toBeNull();
-      }
-    );
-
-    it(
-      "should list issues",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        await createTestIssue("E2E Test Issue - List 1");
-        await createTestIssue("E2E Test Issue - List 2");
-
-        const issues = await client.listIssues();
-
-        expect(Array.isArray(issues)).toBe(true);
-        expect(issues.length).toBeGreaterThanOrEqual(2);
-      }
-    );
-
-    it(
-      "should filter issues by status",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        await createTestIssue("E2E Open Issue");
-
-        const openIssues = await client.listIssues({ status: "open" });
-
-        expect(Array.isArray(openIssues)).toBe(true);
-        expect(openIssues.every((i) => i.status === "open")).toBe(true);
-      }
-    );
-
-    it(
-      "should search issues by text",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        const uniqueText = `unique-search-term-${Date.now()}`;
-        await createTestIssue(`E2E Search Issue ${uniqueText}`);
-
-        const results = await client.listIssues({ search: uniqueText });
-
-        expect(results.length).toBeGreaterThanOrEqual(1);
-        expect(results.some((i) => i.title.includes(uniqueText))).toBe(true);
-      }
-    );
-
-    it(
-      "should get ready issues",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        await createTestIssue("E2E Ready Issue");
-
-        const readyIssues = await client.getReadyIssues();
-
-        expect(Array.isArray(readyIssues)).toBe(true);
-      }
-    );
-
-    it(
-      "should update an issue",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        const created = await createTestIssue("E2E Test Issue - Update");
-
-        const updated = await client.updateIssue(created.id, {
-          title: "E2E Test Issue - Updated",
-          status: "in_progress",
-        });
-
-        expect(updated.title).toBe("E2E Test Issue - Updated");
-        expect(updated.status).toBe("in_progress");
-
-        // Verify persistence
-        const retrieved = await client.getIssue(created.id);
-        expect(retrieved!.title).toBe("E2E Test Issue - Updated");
-      }
-    );
-  });
-
-  describe("Spec Operations", () => {
-    it(
-      "should get a spec by ID",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        const created = await createTestSpec("E2E Test Spec - Get");
-
-        const spec = await client.getSpec(created.id);
-
-        expect(spec).not.toBeNull();
-        expect(spec!.id).toBe(created.id);
-        expect(spec!.title).toBe("E2E Test Spec - Get");
-      }
-    );
-
-    it(
-      "should return null for non-existent spec",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        const spec = await client.getSpec("s-nonexistent-12345");
-        expect(spec).toBeNull();
-      }
-    );
-
-    it(
-      "should list specs",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        await createTestSpec("E2E Test Spec - List 1");
-        await createTestSpec("E2E Test Spec - List 2");
-
-        const specs = await client.listSpecs();
-
-        expect(Array.isArray(specs)).toBe(true);
-        expect(specs.length).toBeGreaterThanOrEqual(2);
-      }
-    );
-
-    it(
-      "should search specs by text",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        const uniqueText = `unique-spec-term-${Date.now()}`;
-        await createTestSpec(`E2E Search Spec ${uniqueText}`);
-
-        const results = await client.listSpecs({ search: uniqueText });
-
-        expect(results.length).toBeGreaterThanOrEqual(1);
-        expect(results.some((s) => s.title.includes(uniqueText))).toBe(true);
-      }
-    );
-  });
-
-  describe("Relationship Operations", () => {
-    it(
-      "should create and query blocking relationships",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        const blocker = await createTestIssue("E2E Blocker Issue");
-        const blocked = await createTestIssue("E2E Blocked Issue");
-
-        // Create blocks relationship
-        await client.createLink(blocker.id, blocked.id, "blocks");
-
-        // Query blockers
-        const blockers = await client.getBlockers(blocked.id);
-        expect(blockers.some((b) => b.id === blocker.id)).toBe(true);
-
-        // Query blocking
-        const blocking = await client.getBlocking(blocker.id);
-        expect(blocking.some((b) => b.id === blocked.id)).toBe(true);
-      }
-    );
-
-    it(
-      "should remove blocking relationships",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        const blocker = await createTestIssue("E2E Blocker to Remove");
-        const blocked = await createTestIssue("E2E Blocked to Unblock");
-
-        // Create and then remove relationship
-        await client.createLink(blocker.id, blocked.id, "blocks");
-        await client.removeLink(blocker.id, blocked.id, "blocks");
-
-        // Verify removal
-        const blockers = await client.getBlockers(blocked.id);
-        expect(blockers.every((b) => b.id !== blocker.id)).toBe(true);
-      }
-    );
-
-    it(
-      "should create implements relationship",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        const spec = await createTestSpec("E2E Spec to Implement");
-        const issue = await createTestIssue("E2E Implementing Issue");
-
-        // Create implements relationship - should complete without error
-        await client.createLink(issue.id, spec.id, "implements");
-      }
-    );
-  });
-
-  describe("Event Subscriptions", () => {
-    it(
-      "should receive events when issues change",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        const events: Array<{ type: string; issueId: string }> = [];
-
-        const unsubscribe = client.onIssueChange((event) => {
-          events.push({ type: event.type, issueId: event.issueId });
-        });
-
-        try {
-          // Create an issue to trigger an event
-          const issue = await createTestIssue("E2E Event Test Issue");
-
-          // Wait for the issue to be available via the client (with retry)
-          let issueAvailable = false;
-          for (let i = 0; i < 10; i++) {
-            const found = await client.getIssue(issue.id);
-            if (found) {
-              issueAvailable = true;
-              break;
-            }
-            await new Promise((r) => setTimeout(r, 200));
-          }
-
-          if (!issueAvailable) {
-            // Skip update if issue not available - this is a server sync issue
-            console.warn(`Issue ${issue.id} not available via client, skipping update`);
-          } else {
-            // Update the issue
-            await client.updateIssue(issue.id, { title: "E2E Updated Title" });
-          }
-
-          await new Promise((r) => setTimeout(r, 500));
-
-          // We should have received some events
-          // Note: This depends on server WebSocket implementation
-          expect(events.length).toBeGreaterThanOrEqual(0);
-        } finally {
-          unsubscribe();
-        }
-      }
-    );
-
-    it(
-      "should filter events by issue ID",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        const issue1 = await createTestIssue("E2E Event Filter Issue 1");
-        const issue2 = await createTestIssue("E2E Event Filter Issue 2");
-
-        const events: string[] = [];
-
-        const unsubscribe = client.onIssueChange(issue1.id, (event) => {
-          events.push(event.issueId);
-        });
-
-        try {
-          // Update both issues
-          await client.updateIssue(issue1.id, { title: "Updated 1" });
-          await client.updateIssue(issue2.id, { title: "Updated 2" });
-
-          await new Promise((r) => setTimeout(r, 500));
-
-          // Should only have events for issue1 (if any)
-          expect(events.every((id) => id === issue1.id)).toBe(true);
-        } finally {
-          unsubscribe();
-        }
-      }
-    );
-  });
-
-  describe("Feedback Operations", () => {
-    it(
-      "should add feedback to a spec",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        const spec = await createTestSpec("E2E Feedback Target Spec");
-        const issue = await createTestIssue("E2E Feedback Source Issue");
-
-        // Add feedback - should complete without error
-        await client.addFeedback(issue.id, spec.id, {
-          type: "suggestion",
-          content: "E2E test feedback content",
-          agent: "e2e-test-agent",
-        });
-      }
-    );
-
-    it(
-      "should add anonymous feedback",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        const spec = await createTestSpec("E2E Anonymous Feedback Spec");
-
-        // Add anonymous feedback
-        await client.addFeedback(undefined, spec.id, {
-          type: "comment",
-          content: "E2E anonymous feedback",
-        });
-      }
-    );
-  });
-
-  describe("Error Handling", () => {
-    it(
-      "should handle server errors gracefully",
-      { timeout: TEST_TIMEOUT },
-      async () => {
-        // Try to update a non-existent issue
-        await expect(
-          client.updateIssue("i-nonexistent-99999", { title: "Won't work" })
-        ).rejects.toThrow();
-      }
-    );
-  });
-});