mirror of
https://github.com/Ark0N/Codeman.git
synced 2026-09-30 12:39:42 +02:00
test: add comprehensive test suite with 129 tests
- Add PTY interactive session tests - Add SSE event streaming tests - Add scheduled runs API tests - Add edge case and error handling tests - Add integration flow tests for user workflows - Add respawn controller tests with edge cases - Add session cleanup and resource management tests Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
arkon
@@ -0,0 +1,400 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import { WebServer } from '../src/web/server.js';
|
||||
import { existsSync, rmSync } from 'node:fs';
|
||||
import { join } from 'node:path';
|
||||
import { homedir } from 'node:os';
|
||||
|
||||
const TEST_PORT = 3110;
|
||||
const CASES_DIR = join(homedir(), 'claudeman-cases');
|
||||
|
||||
describe('Edge Cases and Error Handling', () => {
|
||||
let server: WebServer;
|
||||
let baseUrl: string;
|
||||
const createdCases: string[] = [];
|
||||
|
||||
beforeAll(async () => {
|
||||
server = new WebServer(TEST_PORT);
|
||||
await server.start();
|
||||
baseUrl = `http://localhost:${TEST_PORT}`;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.stop();
|
||||
for (const caseName of createdCases) {
|
||||
const casePath = join(CASES_DIR, caseName);
|
||||
if (existsSync(casePath)) {
|
||||
rmSync(casePath, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
}, 30000);
|
||||
|
||||
describe('Session Edge Cases', () => {
|
||||
it('should handle deleting non-existent session gracefully', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions/non-existent-id-12345`, {
|
||||
method: 'DELETE',
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(false);
|
||||
expect(data.error).toBe('Session not found');
|
||||
});
|
||||
|
||||
it('should handle getting non-existent session gracefully', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions/non-existent-id-12345`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.error).toBe('Session not found');
|
||||
});
|
||||
|
||||
it('should handle running prompt on non-existent session', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions/non-existent/run`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ prompt: 'test' }),
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.error).toBe('Session not found');
|
||||
});
|
||||
|
||||
it('should handle input to non-existent session', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions/non-existent/input`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ input: 'test' }),
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.error).toBe('Session not found');
|
||||
});
|
||||
|
||||
it('should handle resize on non-existent session', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions/non-existent/resize`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ cols: 80, rows: 24 }),
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.error).toBe('Session not found');
|
||||
});
|
||||
|
||||
it('should handle interactive mode on non-existent session', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions/non-existent/interactive`, {
|
||||
method: 'POST',
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.error).toBe('Session not found');
|
||||
});
|
||||
|
||||
it('should handle terminal buffer request on non-existent session', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions/non-existent/terminal`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.error).toBe('Session not found');
|
||||
});
|
||||
|
||||
it('should handle output request on non-existent session', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions/non-existent/output`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.error).toBe('Session not found');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Case Edge Cases', () => {
|
||||
it('should reject empty case name', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/cases`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ name: '' }),
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(false);
|
||||
expect(data.error).toContain('Invalid case name');
|
||||
});
|
||||
|
||||
it('should reject case name with only special characters', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/cases`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ name: '!@#$%^' }),
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(false);
|
||||
expect(data.error).toContain('Invalid case name');
|
||||
});
|
||||
|
||||
it('should reject case name with path traversal attempt', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/cases`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ name: '../escape' }),
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(false);
|
||||
expect(data.error).toContain('Invalid case name');
|
||||
});
|
||||
|
||||
it('should handle getting non-existent case', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/cases/this-case-does-not-exist-12345`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.error).toBe('Case not found');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Quick Start Edge Cases', () => {
|
||||
it('should reject quick start with empty case name', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName: '' }),
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(false);
|
||||
expect(data.error).toContain('Invalid case name');
|
||||
});
|
||||
|
||||
it('should reject quick start with special characters', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName: 'test/../../etc/passwd' }),
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(false);
|
||||
expect(data.error).toContain('Invalid case name');
|
||||
});
|
||||
|
||||
it('should handle very long case names gracefully', async () => {
|
||||
// Test with a very long but valid case name
|
||||
const longName = 'a'.repeat(100);
|
||||
const response = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName: longName }),
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
// Should succeed with valid characters, even if long
|
||||
if (data.success) {
|
||||
createdCases.push(longName);
|
||||
}
|
||||
// Either succeeds or fails gracefully
|
||||
expect(data).toHaveProperty('success');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Respawn Controller Edge Cases', () => {
|
||||
it('should handle getting respawn status for non-existent session', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions/non-existent/respawn`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.enabled).toBe(false);
|
||||
expect(data.status).toBeNull();
|
||||
});
|
||||
|
||||
it('should handle starting respawn on non-existent session', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions/non-existent/respawn/start`, {
|
||||
method: 'POST',
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.error).toBe('Session not found');
|
||||
});
|
||||
|
||||
it('should handle stopping non-existent respawn controller', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions/non-existent/respawn/stop`, {
|
||||
method: 'POST',
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.error).toBe('Respawn controller not found');
|
||||
});
|
||||
|
||||
it('should handle updating config on non-existent respawn controller', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions/non-existent/respawn/config`, {
|
||||
method: 'PUT',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ idleTimeoutMs: 5000 }),
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.error).toBe('Respawn controller not found');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Scheduled Run Edge Cases', () => {
|
||||
it('should handle stopping non-existent scheduled run', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/scheduled/non-existent`, {
|
||||
method: 'DELETE',
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(false);
|
||||
expect(data.error).toBe('Scheduled run not found');
|
||||
});
|
||||
|
||||
it('should handle getting non-existent scheduled run', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/scheduled/non-existent`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.error).toBe('Scheduled run not found');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('Concurrent Session Handling', () => {
|
||||
let server: WebServer;
|
||||
let baseUrl: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = new WebServer(TEST_PORT + 1);
|
||||
await server.start();
|
||||
baseUrl = `http://localhost:${TEST_PORT + 1}`;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.stop();
|
||||
}, 30000);
|
||||
|
||||
it('should handle multiple sessions simultaneously', async () => {
|
||||
// Create multiple sessions concurrently
|
||||
const createPromises = Array(5).fill(null).map(() =>
|
||||
fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ workingDir: '/tmp' }),
|
||||
}).then(r => r.json())
|
||||
);
|
||||
|
||||
const results = await Promise.all(createPromises);
|
||||
|
||||
// All should succeed
|
||||
for (const result of results) {
|
||||
expect(result.success).toBe(true);
|
||||
expect(result.session.id).toBeDefined();
|
||||
}
|
||||
|
||||
// Verify sessions are listed
|
||||
const listRes = await fetch(`${baseUrl}/api/sessions`);
|
||||
const sessions = await listRes.json();
|
||||
expect(sessions.length).toBeGreaterThanOrEqual(5);
|
||||
|
||||
// Clean up - delete all created sessions
|
||||
for (const result of results) {
|
||||
await fetch(`${baseUrl}/api/sessions/${result.session.id}`, {
|
||||
method: 'DELETE',
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
it('should handle rapid session creation and deletion', async () => {
|
||||
const iterations = 10;
|
||||
|
||||
for (let i = 0; i < iterations; i++) {
|
||||
// Create
|
||||
const createRes = await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ workingDir: '/tmp' }),
|
||||
});
|
||||
const createData = await createRes.json();
|
||||
expect(createData.success).toBe(true);
|
||||
|
||||
// Delete immediately
|
||||
const deleteRes = await fetch(`${baseUrl}/api/sessions/${createData.session.id}`, {
|
||||
method: 'DELETE',
|
||||
});
|
||||
const deleteData = await deleteRes.json();
|
||||
expect(deleteData.success).toBe(true);
|
||||
}
|
||||
});
|
||||
|
||||
it('should handle multiple quick starts concurrently', async () => {
|
||||
const caseNames = ['concurrent-test-1', 'concurrent-test-2', 'concurrent-test-3'];
|
||||
const createdCases: string[] = [];
|
||||
|
||||
const quickStartPromises = caseNames.map(name =>
|
||||
fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName: `${name}-${Date.now()}` }),
|
||||
}).then(r => r.json())
|
||||
);
|
||||
|
||||
const results = await Promise.all(quickStartPromises);
|
||||
|
||||
for (const result of results) {
|
||||
expect(result.success).toBe(true);
|
||||
if (result.caseName) {
|
||||
createdCases.push(result.caseName);
|
||||
}
|
||||
}
|
||||
|
||||
// Cleanup
|
||||
const { rmSync, existsSync } = await import('node:fs');
|
||||
const { join } = await import('node:path');
|
||||
const { homedir } = await import('node:os');
|
||||
for (const name of createdCases) {
|
||||
const path = join(homedir(), 'claudeman-cases', name);
|
||||
if (existsSync(path)) {
|
||||
rmSync(path, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('API Request Validation', () => {
|
||||
let server: WebServer;
|
||||
let baseUrl: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = new WebServer(TEST_PORT + 2);
|
||||
await server.start();
|
||||
baseUrl = `http://localhost:${TEST_PORT + 2}`;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.stop();
|
||||
}, 30000);
|
||||
|
||||
it('should handle malformed JSON in request body', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: 'not valid json',
|
||||
});
|
||||
|
||||
// Should return an error status
|
||||
expect(response.status).toBeGreaterThanOrEqual(400);
|
||||
});
|
||||
|
||||
it('should handle empty request body when one is expected', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: '',
|
||||
});
|
||||
|
||||
// Should either succeed with defaults or return appropriate error
|
||||
// Fastify handles this gracefully
|
||||
expect([200, 400, 500]).toContain(response.status);
|
||||
});
|
||||
|
||||
it('should handle requests with missing content-type', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
});
|
||||
|
||||
// Should work or fail gracefully
|
||||
expect(response.status).toBeDefined();
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,356 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import { WebServer } from '../src/web/server.js';
|
||||
import { existsSync, rmSync } from 'node:fs';
|
||||
import { join } from 'node:path';
|
||||
import { homedir } from 'node:os';
|
||||
|
||||
const TEST_PORT = 3115;
|
||||
const CASES_DIR = join(homedir(), 'claudeman-cases');
|
||||
|
||||
/**
|
||||
* Integration tests for complete user flows
|
||||
* These tests verify end-to-end scenarios that users would perform
|
||||
*/
|
||||
describe('Integration Flows', () => {
|
||||
let server: WebServer;
|
||||
let baseUrl: string;
|
||||
const createdCases: string[] = [];
|
||||
const createdSessions: string[] = [];
|
||||
|
||||
beforeAll(async () => {
|
||||
server = new WebServer(TEST_PORT);
|
||||
await server.start();
|
||||
baseUrl = `http://localhost:${TEST_PORT}`;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
// Cleanup sessions
|
||||
for (const sessionId of createdSessions) {
|
||||
try {
|
||||
await fetch(`${baseUrl}/api/sessions/${sessionId}`, { method: 'DELETE' });
|
||||
} catch {}
|
||||
}
|
||||
// Cleanup cases
|
||||
for (const caseName of createdCases) {
|
||||
const casePath = join(CASES_DIR, caseName);
|
||||
if (existsSync(casePath)) {
|
||||
rmSync(casePath, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
await server.stop();
|
||||
}, 60000);
|
||||
|
||||
describe('Quick Start to Interactive Session Flow', () => {
|
||||
it('should complete full quick start flow: create case -> start session -> interactive mode', async () => {
|
||||
const caseName = `flow-test-${Date.now()}`;
|
||||
createdCases.push(caseName);
|
||||
|
||||
// Step 1: Quick start (creates case + session + starts interactive)
|
||||
const quickStartRes = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName }),
|
||||
});
|
||||
const quickStartData = await quickStartRes.json();
|
||||
|
||||
expect(quickStartData.success).toBe(true);
|
||||
expect(quickStartData.sessionId).toBeDefined();
|
||||
expect(quickStartData.caseName).toBe(caseName);
|
||||
createdSessions.push(quickStartData.sessionId);
|
||||
|
||||
// Step 2: Verify session is in interactive mode
|
||||
const sessionRes = await fetch(`${baseUrl}/api/sessions/${quickStartData.sessionId}`);
|
||||
const sessionData = await sessionRes.json();
|
||||
|
||||
expect(sessionData.id).toBe(quickStartData.sessionId);
|
||||
expect(sessionData.workingDir).toContain(caseName);
|
||||
expect(sessionData.status).toBe('busy'); // Interactive sessions are 'busy'
|
||||
|
||||
// Step 3: Verify case was created with CLAUDE.md
|
||||
const caseRes = await fetch(`${baseUrl}/api/cases/${caseName}`);
|
||||
const caseData = await caseRes.json();
|
||||
|
||||
expect(caseData.name).toBe(caseName);
|
||||
expect(caseData.hasClaudeMd).toBe(true);
|
||||
});
|
||||
|
||||
it('should reuse existing case when quick starting with existing case name', async () => {
|
||||
const caseName = `reuse-test-${Date.now()}`;
|
||||
createdCases.push(caseName);
|
||||
|
||||
// First quick start - creates the case
|
||||
const firstRes = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName }),
|
||||
});
|
||||
const firstData = await firstRes.json();
|
||||
expect(firstData.success).toBe(true);
|
||||
createdSessions.push(firstData.sessionId);
|
||||
|
||||
// Delete the session but keep the case
|
||||
await fetch(`${baseUrl}/api/sessions/${firstData.sessionId}`, { method: 'DELETE' });
|
||||
|
||||
// Second quick start - should reuse the case
|
||||
const secondRes = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName }),
|
||||
});
|
||||
const secondData = await secondRes.json();
|
||||
|
||||
expect(secondData.success).toBe(true);
|
||||
expect(secondData.caseName).toBe(caseName);
|
||||
expect(secondData.casePath).toBe(firstData.casePath);
|
||||
createdSessions.push(secondData.sessionId);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Manual Case and Session Flow', () => {
|
||||
it('should complete manual flow: create case -> create session -> start interactive', async () => {
|
||||
const caseName = `manual-flow-${Date.now()}`;
|
||||
createdCases.push(caseName);
|
||||
|
||||
// Step 1: Create case
|
||||
const caseRes = await fetch(`${baseUrl}/api/cases`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ name: caseName, description: 'Test case for manual flow' }),
|
||||
});
|
||||
const caseData = await caseRes.json();
|
||||
expect(caseData.success).toBe(true);
|
||||
|
||||
// Step 2: Create session with case directory
|
||||
const sessionRes = await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ workingDir: caseData.case.path }),
|
||||
});
|
||||
const sessionData = await sessionRes.json();
|
||||
expect(sessionData.success).toBe(true);
|
||||
createdSessions.push(sessionData.session.id);
|
||||
|
||||
// Step 3: Start interactive mode
|
||||
const interactiveRes = await fetch(`${baseUrl}/api/sessions/${sessionData.session.id}/interactive`, {
|
||||
method: 'POST',
|
||||
});
|
||||
const interactiveData = await interactiveRes.json();
|
||||
expect(interactiveData.success).toBe(true);
|
||||
|
||||
// Verify session state
|
||||
const verifyRes = await fetch(`${baseUrl}/api/sessions/${sessionData.session.id}`);
|
||||
const verifyData = await verifyRes.json();
|
||||
expect(verifyData.status).toBe('busy');
|
||||
expect(verifyData.workingDir).toContain(caseName);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Session Input Flow', () => {
|
||||
it('should handle input to interactive session', async () => {
|
||||
const caseName = `input-flow-${Date.now()}`;
|
||||
createdCases.push(caseName);
|
||||
|
||||
// Quick start to get interactive session
|
||||
const quickStartRes = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName }),
|
||||
});
|
||||
const quickStartData = await quickStartRes.json();
|
||||
expect(quickStartData.success).toBe(true);
|
||||
createdSessions.push(quickStartData.sessionId);
|
||||
|
||||
// Wait for Claude to start up
|
||||
await new Promise(resolve => setTimeout(resolve, 2000));
|
||||
|
||||
// Send input
|
||||
const inputRes = await fetch(`${baseUrl}/api/sessions/${quickStartData.sessionId}/input`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ input: '/help\n' }),
|
||||
});
|
||||
const inputData = await inputRes.json();
|
||||
expect(inputData.success).toBe(true);
|
||||
|
||||
// Wait for response
|
||||
await new Promise(resolve => setTimeout(resolve, 1000));
|
||||
|
||||
// Check terminal buffer has content
|
||||
const terminalRes = await fetch(`${baseUrl}/api/sessions/${quickStartData.sessionId}/terminal`);
|
||||
const terminalData = await terminalRes.json();
|
||||
expect(terminalData.terminalBuffer.length).toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
it('should handle terminal resize', async () => {
|
||||
const caseName = `resize-flow-${Date.now()}`;
|
||||
createdCases.push(caseName);
|
||||
|
||||
// Quick start
|
||||
const quickStartRes = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName }),
|
||||
});
|
||||
const quickStartData = await quickStartRes.json();
|
||||
expect(quickStartData.success).toBe(true);
|
||||
createdSessions.push(quickStartData.sessionId);
|
||||
|
||||
// Resize terminal
|
||||
const resizeRes = await fetch(`${baseUrl}/api/sessions/${quickStartData.sessionId}/resize`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ cols: 200, rows: 50 }),
|
||||
});
|
||||
const resizeData = await resizeRes.json();
|
||||
expect(resizeData.success).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Session Cleanup Flow', () => {
|
||||
it('should properly stop and delete session', async () => {
|
||||
const caseName = `cleanup-flow-${Date.now()}`;
|
||||
createdCases.push(caseName);
|
||||
|
||||
// Create session via quick start
|
||||
const quickStartRes = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName }),
|
||||
});
|
||||
const quickStartData = await quickStartRes.json();
|
||||
expect(quickStartData.success).toBe(true);
|
||||
|
||||
// Delete the session
|
||||
const deleteRes = await fetch(`${baseUrl}/api/sessions/${quickStartData.sessionId}`, {
|
||||
method: 'DELETE',
|
||||
});
|
||||
const deleteData = await deleteRes.json();
|
||||
expect(deleteData.success).toBe(true);
|
||||
|
||||
// Verify session is gone
|
||||
const verifyRes = await fetch(`${baseUrl}/api/sessions/${quickStartData.sessionId}`);
|
||||
const verifyData = await verifyRes.json();
|
||||
expect(verifyData.error).toBe('Session not found');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Full Status API Flow', () => {
|
||||
it('should return consistent state across status API', async () => {
|
||||
const caseName = `status-flow-${Date.now()}`;
|
||||
createdCases.push(caseName);
|
||||
|
||||
// Create a session
|
||||
const quickStartRes = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName }),
|
||||
});
|
||||
const quickStartData = await quickStartRes.json();
|
||||
expect(quickStartData.success).toBe(true);
|
||||
createdSessions.push(quickStartData.sessionId);
|
||||
|
||||
// Get full status
|
||||
const statusRes = await fetch(`${baseUrl}/api/status`);
|
||||
const statusData = await statusRes.json();
|
||||
|
||||
expect(statusData.sessions).toBeDefined();
|
||||
expect(Array.isArray(statusData.sessions)).toBe(true);
|
||||
expect(statusData.scheduledRuns).toBeDefined();
|
||||
expect(statusData.respawnStatus).toBeDefined();
|
||||
expect(statusData.timestamp).toBeDefined();
|
||||
|
||||
// Verify our session is in the list
|
||||
const ourSession = statusData.sessions.find((s: any) => s.id === quickStartData.sessionId);
|
||||
expect(ourSession).toBeDefined();
|
||||
expect(ourSession.workingDir).toContain(caseName);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('SSE Event Flow', () => {
|
||||
let server: WebServer;
|
||||
let baseUrl: string;
|
||||
const createdCases: string[] = [];
|
||||
const createdSessions: string[] = [];
|
||||
|
||||
beforeAll(async () => {
|
||||
server = new WebServer(TEST_PORT + 1);
|
||||
await server.start();
|
||||
baseUrl = `http://localhost:${TEST_PORT + 1}`;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
for (const sessionId of createdSessions) {
|
||||
try {
|
||||
await fetch(`${baseUrl}/api/sessions/${sessionId}`, { method: 'DELETE' });
|
||||
} catch {}
|
||||
}
|
||||
for (const caseName of createdCases) {
|
||||
const casePath = join(CASES_DIR, caseName);
|
||||
if (existsSync(casePath)) {
|
||||
rmSync(casePath, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
await server.stop();
|
||||
}, 60000);
|
||||
|
||||
it('should receive all expected events during quick start flow', async () => {
|
||||
const caseName = `sse-flow-${Date.now()}`;
|
||||
createdCases.push(caseName);
|
||||
|
||||
// Start SSE connection
|
||||
const controller = new AbortController();
|
||||
let receivedData = '';
|
||||
const receivedEvents: string[] = [];
|
||||
|
||||
const fetchPromise = fetch(`${baseUrl}/api/events`, {
|
||||
signal: controller.signal,
|
||||
}).then(async response => {
|
||||
const reader = response.body?.getReader();
|
||||
if (reader) {
|
||||
try {
|
||||
while (true) {
|
||||
const { done, value } = await reader.read();
|
||||
if (done) break;
|
||||
const chunk = new TextDecoder().decode(value);
|
||||
receivedData += chunk;
|
||||
// Extract event types
|
||||
const lines = chunk.split('\n');
|
||||
for (const line of lines) {
|
||||
if (line.startsWith('event: ')) {
|
||||
receivedEvents.push(line.substring(7));
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch {}
|
||||
}
|
||||
});
|
||||
|
||||
// Wait for connection
|
||||
await new Promise(resolve => setTimeout(resolve, 100));
|
||||
|
||||
// Perform quick start
|
||||
const quickStartRes = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName }),
|
||||
});
|
||||
const quickStartData = await quickStartRes.json();
|
||||
expect(quickStartData.success).toBe(true);
|
||||
createdSessions.push(quickStartData.sessionId);
|
||||
|
||||
// Wait for events
|
||||
await new Promise(resolve => setTimeout(resolve, 500));
|
||||
|
||||
// Stop SSE
|
||||
controller.abort();
|
||||
try { await fetchPromise; } catch {}
|
||||
|
||||
// Verify expected events were received
|
||||
expect(receivedEvents).toContain('init');
|
||||
expect(receivedEvents).toContain('session:created');
|
||||
expect(receivedEvents).toContain('session:interactive');
|
||||
// case:created should be emitted for new cases
|
||||
expect(receivedEvents).toContain('case:created');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,311 @@
|
||||
import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
|
||||
import { Session } from '../src/session.js';
|
||||
import { existsSync } from 'node:fs';
|
||||
import { join } from 'node:path';
|
||||
import { homedir } from 'node:os';
|
||||
|
||||
/**
|
||||
* PTY/Interactive Session Tests
|
||||
*
|
||||
* These tests verify that:
|
||||
* 1. Claude CLI is spawned with correct flags (--dangerously-skip-permissions)
|
||||
* 2. Interactive sessions open a TTY
|
||||
* 3. Input can be sent to the terminal
|
||||
* 4. Output is received from the terminal
|
||||
* 5. The session properly detects idle/working states
|
||||
*/
|
||||
|
||||
describe('PTY Interactive Session', () => {
|
||||
// Use /tmp which always exists instead of a timestamped directory
|
||||
const testDir = '/tmp';
|
||||
|
||||
describe('Session Spawning', () => {
|
||||
it('should spawn interactive session with correct flags', async () => {
|
||||
const session = new Session({ workingDir: testDir });
|
||||
|
||||
// Track what's being spawned
|
||||
let terminalOutput = '';
|
||||
session.on('terminal', (data: string) => {
|
||||
terminalOutput += data;
|
||||
});
|
||||
|
||||
await session.startInteractive();
|
||||
|
||||
// Session should have a PID (process is running)
|
||||
expect(session.pid).toBeGreaterThan(0);
|
||||
expect(session.status).toBe('busy');
|
||||
|
||||
// Wait a bit for Claude to initialize
|
||||
await new Promise(resolve => setTimeout(resolve, 2000));
|
||||
|
||||
// Terminal output may or may not have content depending on Claude's startup speed
|
||||
// Just verify the session was started successfully
|
||||
expect(session.isRunning()).toBe(true);
|
||||
|
||||
// Clean up
|
||||
await session.stop();
|
||||
});
|
||||
|
||||
it('should emit terminal events with raw PTY data', async () => {
|
||||
const session = new Session({ workingDir: testDir });
|
||||
|
||||
const terminalEvents: string[] = [];
|
||||
session.on('terminal', (data: string) => {
|
||||
terminalEvents.push(data);
|
||||
});
|
||||
|
||||
await session.startInteractive();
|
||||
|
||||
// Wait for some output
|
||||
await new Promise(resolve => setTimeout(resolve, 2000));
|
||||
|
||||
// Session should be running regardless of output
|
||||
expect(session.isRunning()).toBe(true);
|
||||
|
||||
// Terminal events may or may not have been received depending on timing
|
||||
// The important thing is the session is working
|
||||
expect(session.pid).toBeGreaterThan(0);
|
||||
|
||||
await session.stop();
|
||||
});
|
||||
|
||||
it('should accept input via write() method', async () => {
|
||||
const session = new Session({ workingDir: testDir });
|
||||
|
||||
let terminalOutput = '';
|
||||
session.on('terminal', (data: string) => {
|
||||
terminalOutput += data;
|
||||
});
|
||||
|
||||
await session.startInteractive();
|
||||
|
||||
// Wait for Claude to be ready
|
||||
await new Promise(resolve => setTimeout(resolve, 2000));
|
||||
|
||||
// Send some input (just a newline to test input works)
|
||||
session.write('\n');
|
||||
|
||||
// Wait for response
|
||||
await new Promise(resolve => setTimeout(resolve, 500));
|
||||
|
||||
// Terminal should have accumulated output
|
||||
expect(terminalOutput.length).toBeGreaterThan(0);
|
||||
|
||||
await session.stop();
|
||||
});
|
||||
|
||||
it('should handle terminal resize', async () => {
|
||||
const session = new Session({ workingDir: testDir });
|
||||
|
||||
await session.startInteractive();
|
||||
|
||||
// Resize should not throw
|
||||
expect(() => {
|
||||
session.resize(80, 24);
|
||||
}).not.toThrow();
|
||||
|
||||
expect(() => {
|
||||
session.resize(200, 50);
|
||||
}).not.toThrow();
|
||||
|
||||
await session.stop();
|
||||
});
|
||||
|
||||
it('should emit exit event when stopped', async () => {
|
||||
const session = new Session({ workingDir: testDir });
|
||||
|
||||
let exitEmitted = false;
|
||||
session.on('exit', () => {
|
||||
exitEmitted = true;
|
||||
});
|
||||
|
||||
await session.startInteractive();
|
||||
|
||||
// Wait for process to start
|
||||
await new Promise(resolve => setTimeout(resolve, 1000));
|
||||
|
||||
await session.stop();
|
||||
|
||||
// Wait for exit event
|
||||
await new Promise(resolve => setTimeout(resolve, 500));
|
||||
|
||||
// Exit event should have been emitted or status should reflect termination
|
||||
// Status can be 'stopped' (if stop() completed) or 'idle' (if PTY exited first)
|
||||
expect(['stopped', 'idle']).toContain(session.status);
|
||||
});
|
||||
|
||||
it('should track terminal buffer', async () => {
|
||||
const session = new Session({ workingDir: testDir });
|
||||
|
||||
await session.startInteractive();
|
||||
|
||||
// Wait for some output
|
||||
await new Promise(resolve => setTimeout(resolve, 2000));
|
||||
|
||||
// Terminal buffer may or may not have content depending on Claude startup timing
|
||||
// The important thing is that the property exists and session is running
|
||||
expect(session.terminalBuffer).toBeDefined();
|
||||
expect(session.isRunning()).toBe(true);
|
||||
|
||||
await session.stop();
|
||||
});
|
||||
|
||||
it('should not allow starting interactive session twice', async () => {
|
||||
const session = new Session({ workingDir: testDir });
|
||||
|
||||
await session.startInteractive();
|
||||
|
||||
// Second call should throw
|
||||
await expect(session.startInteractive()).rejects.toThrow('already has a running process');
|
||||
|
||||
await session.stop();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Idle Detection', () => {
|
||||
it('should detect idle state after prompt appears', async () => {
|
||||
const session = new Session({ workingDir: testDir });
|
||||
|
||||
let idleEmitted = false;
|
||||
session.on('idle', () => {
|
||||
idleEmitted = true;
|
||||
});
|
||||
|
||||
await session.startInteractive();
|
||||
|
||||
// Wait for Claude to initialize and become idle (shows prompt)
|
||||
// This might take a while depending on Claude startup
|
||||
await new Promise(resolve => setTimeout(resolve, 5000));
|
||||
|
||||
// Idle should be emitted once Claude shows its prompt
|
||||
// Note: This depends on Claude actually starting up successfully
|
||||
// which requires the CLI to be installed
|
||||
|
||||
await session.stop();
|
||||
|
||||
// We just verify the session handled everything without errors
|
||||
expect(session.status).toBe('stopped');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Working Detection', () => {
|
||||
it('should detect working state when Claude is processing', async () => {
|
||||
const session = new Session({ workingDir: testDir });
|
||||
|
||||
let workingEmitted = false;
|
||||
session.on('working', () => {
|
||||
workingEmitted = true;
|
||||
});
|
||||
|
||||
await session.startInteractive();
|
||||
|
||||
// Wait for Claude to be ready
|
||||
await new Promise(resolve => setTimeout(resolve, 3000));
|
||||
|
||||
// Send a simple command to trigger work
|
||||
session.write('hello\n');
|
||||
|
||||
// Wait for Claude to process
|
||||
await new Promise(resolve => setTimeout(resolve, 2000));
|
||||
|
||||
await session.stop();
|
||||
|
||||
// We verify the session handled the input without errors
|
||||
expect(session.status).toBe('stopped');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Run Prompt Mode', () => {
|
||||
it('should spawn with -p flag for one-shot prompts', async () => {
|
||||
const session = new Session({ workingDir: testDir });
|
||||
|
||||
let terminalOutput = '';
|
||||
session.on('terminal', (data: string) => {
|
||||
terminalOutput += data;
|
||||
});
|
||||
|
||||
// Use a very simple prompt - this will actually call Claude
|
||||
// We don't wait for completion since that costs API credits
|
||||
const runPromise = session.runPrompt('echo test').catch(() => {
|
||||
// Ignore rejection from stop() - we're intentionally stopping early
|
||||
});
|
||||
|
||||
// Give it a moment to spawn
|
||||
await new Promise(resolve => setTimeout(resolve, 1000));
|
||||
|
||||
// Session should be busy
|
||||
expect(session.status).toBe('busy');
|
||||
expect(session.pid).toBeGreaterThan(0);
|
||||
|
||||
// Stop the session to avoid waiting for API completion
|
||||
await session.stop();
|
||||
|
||||
// Wait for the promise to resolve/reject
|
||||
await runPromise;
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('Session State Management', () => {
|
||||
const testDir = '/tmp';
|
||||
|
||||
it('should transition through states correctly', async () => {
|
||||
const session = new Session({ workingDir: testDir });
|
||||
|
||||
// Initial state
|
||||
expect(session.status).toBe('idle');
|
||||
expect(session.isIdle()).toBe(true);
|
||||
expect(session.isBusy()).toBe(false);
|
||||
|
||||
await session.startInteractive();
|
||||
|
||||
// After starting
|
||||
expect(session.status).toBe('busy');
|
||||
expect(session.isIdle()).toBe(false);
|
||||
expect(session.isBusy()).toBe(true);
|
||||
|
||||
await session.stop();
|
||||
|
||||
// After stopping
|
||||
expect(session.status).toBe('stopped');
|
||||
});
|
||||
|
||||
it('should provide state snapshots', async () => {
|
||||
const session = new Session({ workingDir: testDir });
|
||||
|
||||
const state = session.toState();
|
||||
expect(state).toHaveProperty('id');
|
||||
expect(state).toHaveProperty('pid');
|
||||
expect(state).toHaveProperty('status');
|
||||
expect(state).toHaveProperty('workingDir');
|
||||
expect(state).toHaveProperty('createdAt');
|
||||
expect(state).toHaveProperty('lastActivityAt');
|
||||
|
||||
const detailedState = session.toDetailedState();
|
||||
expect(detailedState).toHaveProperty('totalCost');
|
||||
expect(detailedState).toHaveProperty('textOutput');
|
||||
expect(detailedState).toHaveProperty('terminalBuffer');
|
||||
expect(detailedState).toHaveProperty('messageCount');
|
||||
});
|
||||
|
||||
it('should clear buffers', async () => {
|
||||
const session = new Session({ workingDir: testDir });
|
||||
|
||||
await session.startInteractive();
|
||||
|
||||
// Wait for some output
|
||||
await new Promise(resolve => setTimeout(resolve, 2000));
|
||||
|
||||
// Should have some buffer content
|
||||
expect(session.terminalBuffer.length).toBeGreaterThan(0);
|
||||
|
||||
// Clear buffers
|
||||
session.clearBuffers();
|
||||
|
||||
expect(session.terminalBuffer).toBe('');
|
||||
expect(session.textOutput).toBe('');
|
||||
expect(session.errorBuffer).toBe('');
|
||||
|
||||
await session.stop();
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,309 @@
|
||||
import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
|
||||
import { WebServer } from '../src/web/server.js';
|
||||
import { existsSync, rmSync, mkdirSync } from 'node:fs';
|
||||
import { join } from 'node:path';
|
||||
import { homedir } from 'node:os';
|
||||
|
||||
const TEST_PORT = 3099;
|
||||
const CASES_DIR = join(homedir(), 'claudeman-cases');
|
||||
|
||||
describe('Quick Start API', () => {
|
||||
let server: WebServer;
|
||||
let baseUrl: string;
|
||||
const createdCases: string[] = [];
|
||||
|
||||
beforeAll(async () => {
|
||||
server = new WebServer(TEST_PORT);
|
||||
await server.start();
|
||||
baseUrl = `http://localhost:${TEST_PORT}`;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.stop();
|
||||
// Cleanup created test cases
|
||||
for (const caseName of createdCases) {
|
||||
const casePath = join(CASES_DIR, caseName);
|
||||
if (existsSync(casePath)) {
|
||||
rmSync(casePath, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
describe('POST /api/quick-start', () => {
|
||||
it('should create default testcase and start interactive session', async () => {
|
||||
const testCaseName = 'test-quick-start-default-' + Date.now();
|
||||
createdCases.push(testCaseName);
|
||||
|
||||
const response = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName: testCaseName }),
|
||||
});
|
||||
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(true);
|
||||
expect(data.sessionId).toBeDefined();
|
||||
expect(data.caseName).toBe(testCaseName);
|
||||
expect(data.casePath).toBe(join(CASES_DIR, testCaseName));
|
||||
|
||||
// Verify case folder was created
|
||||
expect(existsSync(data.casePath)).toBe(true);
|
||||
expect(existsSync(join(data.casePath, 'CLAUDE.md'))).toBe(true);
|
||||
expect(existsSync(join(data.casePath, 'src'))).toBe(true);
|
||||
});
|
||||
|
||||
it('should use existing case without recreating it', async () => {
|
||||
const testCaseName = 'test-existing-case-' + Date.now();
|
||||
const casePath = join(CASES_DIR, testCaseName);
|
||||
createdCases.push(testCaseName);
|
||||
|
||||
// Pre-create the case
|
||||
mkdirSync(casePath, { recursive: true });
|
||||
|
||||
const response = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName: testCaseName }),
|
||||
});
|
||||
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(true);
|
||||
expect(data.caseName).toBe(testCaseName);
|
||||
// Case should exist but CLAUDE.md won't be created since case already exists
|
||||
expect(existsSync(casePath)).toBe(true);
|
||||
});
|
||||
|
||||
it('should reject invalid case names with special characters', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName: 'invalid/case\\name!' }),
|
||||
});
|
||||
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(false);
|
||||
expect(data.error).toContain('Invalid case name');
|
||||
});
|
||||
|
||||
it('should reject case names with spaces', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName: 'case with spaces' }),
|
||||
});
|
||||
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(false);
|
||||
expect(data.error).toContain('Invalid case name');
|
||||
});
|
||||
|
||||
it('should accept case names with hyphens and underscores', async () => {
|
||||
const testCaseName = 'test-case_with-mixed_123-' + Date.now();
|
||||
createdCases.push(testCaseName);
|
||||
|
||||
const response = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName: testCaseName }),
|
||||
});
|
||||
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(true);
|
||||
expect(data.caseName).toBe(testCaseName);
|
||||
});
|
||||
|
||||
it('should default to "testcase" when no caseName provided', async () => {
|
||||
// Clean up testcase if it exists from previous runs
|
||||
const testcasePath = join(CASES_DIR, 'testcase');
|
||||
if (!createdCases.includes('testcase')) {
|
||||
createdCases.push('testcase');
|
||||
}
|
||||
|
||||
const response = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({}),
|
||||
});
|
||||
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(true);
|
||||
expect(data.caseName).toBe('testcase');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('Session Management', () => {
|
||||
let server: WebServer;
|
||||
let baseUrl: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = new WebServer(TEST_PORT + 1);
|
||||
await server.start();
|
||||
baseUrl = `http://localhost:${TEST_PORT + 1}`;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.stop();
|
||||
});
|
||||
|
||||
describe('POST /api/sessions', () => {
|
||||
it('should create a new session', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ workingDir: '/tmp' }),
|
||||
});
|
||||
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(true);
|
||||
expect(data.session).toBeDefined();
|
||||
expect(data.session.id).toBeDefined();
|
||||
expect(data.session.workingDir).toBe('/tmp');
|
||||
expect(data.session.status).toBe('idle');
|
||||
});
|
||||
});
|
||||
|
||||
describe('GET /api/sessions', () => {
|
||||
it('should return list of sessions', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(Array.isArray(data)).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('GET /api/status', () => {
|
||||
it('should return full server state', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/status`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(data).toHaveProperty('sessions');
|
||||
expect(data).toHaveProperty('scheduledRuns');
|
||||
expect(data).toHaveProperty('respawnStatus');
|
||||
expect(data).toHaveProperty('timestamp');
|
||||
expect(Array.isArray(data.sessions)).toBe(true);
|
||||
expect(Array.isArray(data.scheduledRuns)).toBe(true);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('Case Management', () => {
|
||||
let server: WebServer;
|
||||
let baseUrl: string;
|
||||
const createdCases: string[] = [];
|
||||
|
||||
beforeAll(async () => {
|
||||
server = new WebServer(TEST_PORT + 2);
|
||||
await server.start();
|
||||
baseUrl = `http://localhost:${TEST_PORT + 2}`;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.stop();
|
||||
for (const caseName of createdCases) {
|
||||
const casePath = join(CASES_DIR, caseName);
|
||||
if (existsSync(casePath)) {
|
||||
rmSync(casePath, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
describe('GET /api/cases', () => {
|
||||
it('should return list of cases', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/cases`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(Array.isArray(data)).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('POST /api/cases', () => {
|
||||
it('should create a new case', async () => {
|
||||
const testCaseName = 'test-case-create-' + Date.now();
|
||||
createdCases.push(testCaseName);
|
||||
|
||||
const response = await fetch(`${baseUrl}/api/cases`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ name: testCaseName, description: 'Test case' }),
|
||||
});
|
||||
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(true);
|
||||
expect(data.case.name).toBe(testCaseName);
|
||||
});
|
||||
|
||||
it('should reject duplicate case names', async () => {
|
||||
const testCaseName = 'test-case-duplicate-' + Date.now();
|
||||
createdCases.push(testCaseName);
|
||||
|
||||
// Create first case
|
||||
await fetch(`${baseUrl}/api/cases`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ name: testCaseName }),
|
||||
});
|
||||
|
||||
// Try to create duplicate
|
||||
const response = await fetch(`${baseUrl}/api/cases`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ name: testCaseName }),
|
||||
});
|
||||
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(false);
|
||||
expect(data.error).toContain('already exists');
|
||||
});
|
||||
|
||||
it('should reject invalid case names', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/cases`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ name: 'invalid name!' }),
|
||||
});
|
||||
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(false);
|
||||
expect(data.error).toContain('Invalid case name');
|
||||
});
|
||||
});
|
||||
|
||||
describe('GET /api/cases/:name', () => {
|
||||
it('should return case details', async () => {
|
||||
const testCaseName = 'test-case-get-' + Date.now();
|
||||
createdCases.push(testCaseName);
|
||||
|
||||
// Create case first
|
||||
await fetch(`${baseUrl}/api/cases`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ name: testCaseName }),
|
||||
});
|
||||
|
||||
const response = await fetch(`${baseUrl}/api/cases/${testCaseName}`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.name).toBe(testCaseName);
|
||||
expect(data.path).toBeDefined();
|
||||
expect(data.hasClaudeMd).toBe(true);
|
||||
});
|
||||
|
||||
it('should return error for non-existent case', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/cases/non-existent-case-12345`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.error).toBe('Case not found');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,485 @@
|
||||
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
|
||||
import { RespawnController, RespawnState, RespawnConfig } from '../src/respawn-controller.js';
|
||||
import { Session } from '../src/session.js';
|
||||
import { EventEmitter } from 'node:events';
|
||||
|
||||
/**
|
||||
* RespawnController Tests
|
||||
*
|
||||
* Tests the state machine that manages automatic respawning of Claude sessions
|
||||
* State flow: WATCHING → SENDING_UPDATE → WAITING_UPDATE → SENDING_CLEAR → WAITING_CLEAR → SENDING_INIT → WAITING_INIT → WATCHING
|
||||
*/
|
||||
|
||||
// Mock Session for testing
|
||||
class MockSession extends EventEmitter {
|
||||
id = 'mock-session-id';
|
||||
workingDir = '/tmp';
|
||||
status = 'idle';
|
||||
writeBuffer: string[] = [];
|
||||
|
||||
write(data: string): void {
|
||||
this.writeBuffer.push(data);
|
||||
}
|
||||
|
||||
// Simulate terminal output
|
||||
simulateTerminalOutput(data: string): void {
|
||||
this.emit('terminal', data);
|
||||
}
|
||||
|
||||
// Simulate prompt appearing
|
||||
simulatePrompt(): void {
|
||||
this.emit('terminal', '❯ ');
|
||||
}
|
||||
|
||||
// Simulate working state
|
||||
simulateWorking(): void {
|
||||
this.emit('terminal', 'Thinking... ⠋');
|
||||
}
|
||||
|
||||
// Simulate clear completion
|
||||
simulateClearComplete(): void {
|
||||
this.emit('terminal', 'conversation cleared');
|
||||
}
|
||||
|
||||
// Simulate init completion
|
||||
simulateInitComplete(): void {
|
||||
this.emit('terminal', 'Analyzing CLAUDE.md...');
|
||||
setTimeout(() => this.simulatePrompt(), 100);
|
||||
}
|
||||
}
|
||||
|
||||
describe('RespawnController', () => {
|
||||
let session: MockSession;
|
||||
let controller: RespawnController;
|
||||
|
||||
beforeEach(() => {
|
||||
session = new MockSession();
|
||||
controller = new RespawnController(session as unknown as Session, {
|
||||
idleTimeoutMs: 100, // Short timeout for testing
|
||||
interStepDelayMs: 50,
|
||||
});
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
controller.stop();
|
||||
});
|
||||
|
||||
describe('Initialization', () => {
|
||||
it('should start in stopped state', () => {
|
||||
expect(controller.state).toBe('stopped');
|
||||
expect(controller.isRunning).toBe(false);
|
||||
});
|
||||
|
||||
it('should have default configuration', () => {
|
||||
const config = controller.getConfig();
|
||||
expect(config.enabled).toBe(true);
|
||||
expect(config.updatePrompt).toBe('update all the docs and CLAUDE.md');
|
||||
});
|
||||
|
||||
it('should allow custom configuration', () => {
|
||||
const customController = new RespawnController(session as unknown as Session, {
|
||||
updatePrompt: 'custom prompt',
|
||||
idleTimeoutMs: 10000,
|
||||
});
|
||||
const config = customController.getConfig();
|
||||
expect(config.updatePrompt).toBe('custom prompt');
|
||||
expect(config.idleTimeoutMs).toBe(10000);
|
||||
customController.stop();
|
||||
});
|
||||
});
|
||||
|
||||
describe('State Machine', () => {
|
||||
it('should transition to watching state on start', () => {
|
||||
const states: RespawnState[] = [];
|
||||
controller.on('stateChanged', (state) => states.push(state));
|
||||
|
||||
controller.start();
|
||||
|
||||
expect(controller.state).toBe('watching');
|
||||
expect(states).toContain('watching');
|
||||
});
|
||||
|
||||
it('should not start if already running', () => {
|
||||
controller.start();
|
||||
const initialState = controller.state;
|
||||
|
||||
controller.start(); // Try to start again
|
||||
|
||||
expect(controller.state).toBe(initialState);
|
||||
});
|
||||
|
||||
it('should transition to stopped on stop', () => {
|
||||
controller.start();
|
||||
controller.stop();
|
||||
|
||||
expect(controller.state).toBe('stopped');
|
||||
expect(controller.isRunning).toBe(false);
|
||||
});
|
||||
|
||||
it('should track cycle count', () => {
|
||||
expect(controller.currentCycle).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Idle Detection', () => {
|
||||
it('should detect prompt pattern', async () => {
|
||||
const logMessages: string[] = [];
|
||||
controller.on('log', (msg) => logMessages.push(msg));
|
||||
|
||||
controller.start();
|
||||
session.simulatePrompt();
|
||||
|
||||
// Wait for log
|
||||
await new Promise(resolve => setTimeout(resolve, 50));
|
||||
|
||||
const hasPromptLog = logMessages.some(msg => msg.includes('Prompt detected'));
|
||||
expect(hasPromptLog).toBe(true);
|
||||
});
|
||||
|
||||
it('should detect multiple prompt patterns', () => {
|
||||
controller.start();
|
||||
|
||||
// All these should trigger prompt detection
|
||||
const promptPatterns = ['❯', '\u276f', '⏵', '> ', 'tokens'];
|
||||
|
||||
for (const pattern of promptPatterns) {
|
||||
session.simulateTerminalOutput(pattern);
|
||||
}
|
||||
|
||||
// Controller should still be running after all patterns
|
||||
expect(controller.isRunning).toBe(true);
|
||||
});
|
||||
|
||||
it('should detect working patterns and clear prompt state', () => {
|
||||
controller.start();
|
||||
session.simulatePrompt();
|
||||
|
||||
// Simulate working - should clear prompt detected
|
||||
session.simulateWorking();
|
||||
|
||||
const status = controller.getStatus();
|
||||
expect(status.workingDetected).toBe(true);
|
||||
expect(status.promptDetected).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Respawn Cycle', () => {
|
||||
it('should start cycle when idle timeout fires', async () => {
|
||||
let cycleStarted = false;
|
||||
controller.on('respawnCycleStarted', () => {
|
||||
cycleStarted = true;
|
||||
});
|
||||
|
||||
controller.start();
|
||||
session.simulatePrompt();
|
||||
|
||||
// Wait for idle timeout
|
||||
await new Promise(resolve => setTimeout(resolve, 200));
|
||||
|
||||
expect(cycleStarted).toBe(true);
|
||||
expect(controller.currentCycle).toBe(1);
|
||||
});
|
||||
|
||||
it('should send update prompt during cycle', async () => {
|
||||
let stepSent: string | null = null;
|
||||
controller.on('stepSent', (step) => {
|
||||
stepSent = step;
|
||||
});
|
||||
|
||||
controller.start();
|
||||
session.simulatePrompt();
|
||||
|
||||
// Wait for idle timeout and step
|
||||
await new Promise(resolve => setTimeout(resolve, 300));
|
||||
|
||||
expect(stepSent).toBe('update');
|
||||
expect(session.writeBuffer.length).toBeGreaterThan(0);
|
||||
expect(session.writeBuffer[0]).toContain('update all the docs');
|
||||
});
|
||||
|
||||
it('should transition through states during cycle', async () => {
|
||||
const states: RespawnState[] = [];
|
||||
controller.on('stateChanged', (state) => states.push(state));
|
||||
|
||||
controller.start();
|
||||
session.simulatePrompt();
|
||||
|
||||
// Wait for initial state change
|
||||
await new Promise(resolve => setTimeout(resolve, 200));
|
||||
|
||||
// Should have transitioned through multiple states
|
||||
expect(states).toContain('watching');
|
||||
expect(states.length).toBeGreaterThan(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Configuration Update', () => {
|
||||
it('should update configuration', () => {
|
||||
controller.updateConfig({ updatePrompt: 'new prompt' });
|
||||
|
||||
const config = controller.getConfig();
|
||||
expect(config.updatePrompt).toBe('new prompt');
|
||||
});
|
||||
|
||||
it('should merge partial configuration', () => {
|
||||
const originalTimeout = controller.getConfig().idleTimeoutMs;
|
||||
controller.updateConfig({ updatePrompt: 'new prompt' });
|
||||
|
||||
const config = controller.getConfig();
|
||||
expect(config.idleTimeoutMs).toBe(originalTimeout);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Status', () => {
|
||||
it('should provide complete status', () => {
|
||||
controller.start();
|
||||
|
||||
const status = controller.getStatus();
|
||||
|
||||
expect(status).toHaveProperty('state');
|
||||
expect(status).toHaveProperty('cycleCount');
|
||||
expect(status).toHaveProperty('lastActivityTime');
|
||||
expect(status).toHaveProperty('timeSinceActivity');
|
||||
expect(status).toHaveProperty('promptDetected');
|
||||
expect(status).toHaveProperty('workingDetected');
|
||||
expect(status).toHaveProperty('config');
|
||||
});
|
||||
|
||||
it('should track time since activity', async () => {
|
||||
controller.start();
|
||||
|
||||
// Wait a bit
|
||||
await new Promise(resolve => setTimeout(resolve, 100));
|
||||
|
||||
const status = controller.getStatus();
|
||||
expect(status.timeSinceActivity).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Disabled State', () => {
|
||||
it('should not start when disabled', () => {
|
||||
const disabledController = new RespawnController(session as unknown as Session, {
|
||||
enabled: false,
|
||||
});
|
||||
|
||||
disabledController.start();
|
||||
|
||||
expect(disabledController.state).toBe('stopped');
|
||||
disabledController.stop();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Pause and Resume', () => {
|
||||
it('should pause without changing state', () => {
|
||||
controller.start();
|
||||
const stateBeforePause = controller.state;
|
||||
|
||||
controller.pause();
|
||||
|
||||
expect(controller.state).toBe(stateBeforePause);
|
||||
});
|
||||
|
||||
it('should resume from watching state', () => {
|
||||
controller.start();
|
||||
controller.pause();
|
||||
controller.resume();
|
||||
|
||||
expect(controller.state).toBe('watching');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Terminal Buffer Management', () => {
|
||||
it('should handle large terminal output', () => {
|
||||
controller.start();
|
||||
|
||||
// Send lots of data
|
||||
const largeData = 'x'.repeat(20000);
|
||||
session.simulateTerminalOutput(largeData);
|
||||
|
||||
// Should not crash and controller should still work
|
||||
expect(controller.isRunning).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Event Emission', () => {
|
||||
it('should emit stateChanged events', async () => {
|
||||
const events: Array<{ state: RespawnState; prevState: RespawnState }> = [];
|
||||
controller.on('stateChanged', (state, prevState) => {
|
||||
events.push({ state, prevState });
|
||||
});
|
||||
|
||||
controller.start();
|
||||
await new Promise(resolve => setTimeout(resolve, 50));
|
||||
|
||||
expect(events.length).toBeGreaterThan(0);
|
||||
expect(events[0].state).toBe('watching');
|
||||
expect(events[0].prevState).toBe('stopped');
|
||||
});
|
||||
|
||||
it('should emit log events', () => {
|
||||
const logs: string[] = [];
|
||||
controller.on('log', (msg) => logs.push(msg));
|
||||
|
||||
controller.start();
|
||||
|
||||
expect(logs.length).toBeGreaterThan(0);
|
||||
expect(logs.some(l => l.includes('Starting'))).toBe(true);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('RespawnController Integration', () => {
|
||||
it('should handle rapid terminal data without errors', () => {
|
||||
const session = new MockSession();
|
||||
const controller = new RespawnController(session as unknown as Session, {
|
||||
idleTimeoutMs: 1000,
|
||||
});
|
||||
|
||||
controller.start();
|
||||
|
||||
// Simulate rapid terminal output
|
||||
for (let i = 0; i < 100; i++) {
|
||||
session.simulateTerminalOutput(`Line ${i}\n`);
|
||||
}
|
||||
|
||||
expect(controller.isRunning).toBe(true);
|
||||
controller.stop();
|
||||
});
|
||||
|
||||
it('should handle mixed working and idle states', async () => {
|
||||
const session = new MockSession();
|
||||
const controller = new RespawnController(session as unknown as Session, {
|
||||
idleTimeoutMs: 100,
|
||||
});
|
||||
|
||||
controller.start();
|
||||
|
||||
// Alternate between working and idle
|
||||
session.simulatePrompt();
|
||||
await new Promise(resolve => setTimeout(resolve, 50));
|
||||
|
||||
session.simulateWorking();
|
||||
await new Promise(resolve => setTimeout(resolve, 50));
|
||||
|
||||
session.simulatePrompt();
|
||||
await new Promise(resolve => setTimeout(resolve, 50));
|
||||
|
||||
// Should handle transitions gracefully
|
||||
expect(controller.isRunning).toBe(true);
|
||||
controller.stop();
|
||||
});
|
||||
|
||||
it('should handle ANSI escape codes in terminal output', () => {
|
||||
const session = new MockSession();
|
||||
const controller = new RespawnController(session as unknown as Session, {
|
||||
idleTimeoutMs: 1000,
|
||||
});
|
||||
|
||||
controller.start();
|
||||
|
||||
// Simulate output with ANSI codes
|
||||
session.simulateTerminalOutput('\x1b[32mGreen text\x1b[0m');
|
||||
session.simulateTerminalOutput('\x1b[1;34mBold blue\x1b[0m');
|
||||
session.simulateTerminalOutput('\x1b[2J\x1b[H'); // Clear screen and move cursor
|
||||
session.simulateTerminalOutput('\x1b[?25l'); // Hide cursor
|
||||
session.simulateTerminalOutput('\x1b[?25h'); // Show cursor
|
||||
|
||||
// Should handle ANSI codes without crashing
|
||||
expect(controller.isRunning).toBe(true);
|
||||
controller.stop();
|
||||
});
|
||||
|
||||
it('should handle empty terminal output', () => {
|
||||
const session = new MockSession();
|
||||
const controller = new RespawnController(session as unknown as Session, {
|
||||
idleTimeoutMs: 1000,
|
||||
});
|
||||
|
||||
controller.start();
|
||||
|
||||
// Simulate empty and whitespace output
|
||||
session.simulateTerminalOutput('');
|
||||
session.simulateTerminalOutput(' ');
|
||||
session.simulateTerminalOutput('\n\n\n');
|
||||
session.simulateTerminalOutput('\t\t');
|
||||
|
||||
expect(controller.isRunning).toBe(true);
|
||||
controller.stop();
|
||||
});
|
||||
|
||||
it('should handle start/stop cycles without memory leaks', () => {
|
||||
const session = new MockSession();
|
||||
|
||||
for (let i = 0; i < 10; i++) {
|
||||
const controller = new RespawnController(session as unknown as Session, {
|
||||
idleTimeoutMs: 100,
|
||||
});
|
||||
controller.start();
|
||||
session.simulatePrompt();
|
||||
session.simulateWorking();
|
||||
session.simulatePrompt();
|
||||
controller.stop();
|
||||
}
|
||||
|
||||
// If we got here without crashing, the test passes
|
||||
expect(true).toBe(true);
|
||||
});
|
||||
|
||||
it('should handle Unicode prompt characters', () => {
|
||||
const session = new MockSession();
|
||||
const controller = new RespawnController(session as unknown as Session, {
|
||||
idleTimeoutMs: 1000,
|
||||
});
|
||||
|
||||
controller.start();
|
||||
|
||||
// Test various prompt characters
|
||||
session.simulateTerminalOutput('❯ ');
|
||||
session.simulateTerminalOutput('\u276f '); // Unicode variant
|
||||
session.simulateTerminalOutput('⏵ '); // Alternative
|
||||
|
||||
const status = controller.getStatus();
|
||||
expect(status.promptDetected).toBe(true);
|
||||
controller.stop();
|
||||
});
|
||||
|
||||
it('should handle spinner animations', () => {
|
||||
const session = new MockSession();
|
||||
const controller = new RespawnController(session as unknown as Session, {
|
||||
idleTimeoutMs: 1000,
|
||||
});
|
||||
|
||||
controller.start();
|
||||
|
||||
// Simulate spinner animation
|
||||
const spinnerChars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
|
||||
for (const char of spinnerChars) {
|
||||
session.simulateTerminalOutput(`Working... ${char}`);
|
||||
}
|
||||
|
||||
const status = controller.getStatus();
|
||||
expect(status.workingDetected).toBe(true);
|
||||
controller.stop();
|
||||
});
|
||||
|
||||
it('should not trigger cycle when disabled', async () => {
|
||||
const session = new MockSession();
|
||||
const controller = new RespawnController(session as unknown as Session, {
|
||||
enabled: false,
|
||||
idleTimeoutMs: 50,
|
||||
});
|
||||
|
||||
let cycleStarted = false;
|
||||
controller.on('respawnCycleStarted', () => {
|
||||
cycleStarted = true;
|
||||
});
|
||||
|
||||
controller.start();
|
||||
session.simulatePrompt();
|
||||
|
||||
await new Promise(resolve => setTimeout(resolve, 200));
|
||||
|
||||
expect(cycleStarted).toBe(false);
|
||||
controller.stop();
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,224 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import { WebServer } from '../src/web/server.js';
|
||||
|
||||
const TEST_PORT = 3105;
|
||||
|
||||
describe('Scheduled Runs API', () => {
|
||||
let server: WebServer;
|
||||
let baseUrl: string;
|
||||
const createdRuns: string[] = [];
|
||||
|
||||
beforeAll(async () => {
|
||||
server = new WebServer(TEST_PORT);
|
||||
await server.start();
|
||||
baseUrl = `http://localhost:${TEST_PORT}`;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
// Cancel any remaining runs
|
||||
for (const runId of createdRuns) {
|
||||
try {
|
||||
await fetch(`${baseUrl}/api/scheduled/${runId}`, { method: 'DELETE' });
|
||||
} catch {}
|
||||
}
|
||||
await server.stop();
|
||||
});
|
||||
|
||||
describe('GET /api/scheduled', () => {
|
||||
it('should return empty list initially', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/scheduled`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(Array.isArray(data)).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('POST /api/scheduled', () => {
|
||||
it('should create a scheduled run', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/scheduled`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
prompt: 'echo test',
|
||||
workingDir: '/tmp',
|
||||
durationMinutes: 1,
|
||||
}),
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(true);
|
||||
expect(data.run).toBeDefined();
|
||||
expect(data.run.id).toBeDefined();
|
||||
expect(data.run.prompt).toBe('echo test');
|
||||
expect(data.run.durationMinutes).toBe(1);
|
||||
expect(data.run.status).toBe('running');
|
||||
|
||||
createdRuns.push(data.run.id);
|
||||
|
||||
// Stop the run immediately to avoid resource usage
|
||||
await fetch(`${baseUrl}/api/scheduled/${data.run.id}`, { method: 'DELETE' });
|
||||
});
|
||||
|
||||
it('should set correct timestamps', async () => {
|
||||
const beforeCreate = Date.now();
|
||||
|
||||
const response = await fetch(`${baseUrl}/api/scheduled`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
prompt: 'test timestamps',
|
||||
durationMinutes: 5,
|
||||
}),
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
const afterCreate = Date.now();
|
||||
|
||||
expect(data.run.startedAt).toBeGreaterThanOrEqual(beforeCreate);
|
||||
expect(data.run.startedAt).toBeLessThanOrEqual(afterCreate);
|
||||
expect(data.run.endAt).toBe(data.run.startedAt + 5 * 60 * 1000);
|
||||
|
||||
createdRuns.push(data.run.id);
|
||||
await fetch(`${baseUrl}/api/scheduled/${data.run.id}`, { method: 'DELETE' });
|
||||
});
|
||||
|
||||
it('should initialize with zero completed tasks and cost', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/scheduled`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
prompt: 'test initial values',
|
||||
durationMinutes: 1,
|
||||
}),
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.run.completedTasks).toBe(0);
|
||||
expect(data.run.totalCost).toBe(0);
|
||||
// Logs may have 1 or more entries depending on timing
|
||||
expect(data.run.logs.length).toBeGreaterThanOrEqual(1);
|
||||
|
||||
createdRuns.push(data.run.id);
|
||||
await fetch(`${baseUrl}/api/scheduled/${data.run.id}`, { method: 'DELETE' });
|
||||
});
|
||||
});
|
||||
|
||||
describe('GET /api/scheduled/:id', () => {
|
||||
it('should return scheduled run details', async () => {
|
||||
// Create a run first
|
||||
const createRes = await fetch(`${baseUrl}/api/scheduled`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
prompt: 'test get',
|
||||
durationMinutes: 1,
|
||||
}),
|
||||
});
|
||||
const createData = await createRes.json();
|
||||
const runId = createData.run.id;
|
||||
createdRuns.push(runId);
|
||||
|
||||
// Get the run
|
||||
const response = await fetch(`${baseUrl}/api/scheduled/${runId}`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.id).toBe(runId);
|
||||
expect(data.prompt).toBe('test get');
|
||||
|
||||
await fetch(`${baseUrl}/api/scheduled/${runId}`, { method: 'DELETE' });
|
||||
});
|
||||
|
||||
it('should return error for non-existent run', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/scheduled/non-existent-id`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.error).toBe('Scheduled run not found');
|
||||
});
|
||||
});
|
||||
|
||||
describe('DELETE /api/scheduled/:id', () => {
|
||||
it('should stop a scheduled run', async () => {
|
||||
// Create a run
|
||||
const createRes = await fetch(`${baseUrl}/api/scheduled`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
prompt: 'test delete',
|
||||
durationMinutes: 10,
|
||||
}),
|
||||
});
|
||||
const createData = await createRes.json();
|
||||
const runId = createData.run.id;
|
||||
|
||||
// Delete/stop the run
|
||||
const response = await fetch(`${baseUrl}/api/scheduled/${runId}`, {
|
||||
method: 'DELETE',
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(true);
|
||||
|
||||
// Verify it's stopped
|
||||
const getRes = await fetch(`${baseUrl}/api/scheduled/${runId}`);
|
||||
const runData = await getRes.json();
|
||||
expect(runData.status).toBe('stopped');
|
||||
});
|
||||
|
||||
it('should return error for non-existent run', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/scheduled/non-existent-id`, {
|
||||
method: 'DELETE',
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(false);
|
||||
expect(data.error).toBe('Scheduled run not found');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('Quick Run API', () => {
|
||||
let server: WebServer;
|
||||
let baseUrl: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = new WebServer(TEST_PORT + 1);
|
||||
await server.start();
|
||||
baseUrl = `http://localhost:${TEST_PORT + 1}`;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.stop();
|
||||
});
|
||||
|
||||
describe('POST /api/run', () => {
|
||||
it('should create session and run prompt', async () => {
|
||||
// Note: This test will actually try to run Claude
|
||||
// We use a simple echo to minimize API usage
|
||||
const response = await fetch(`${baseUrl}/api/run`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
prompt: 'say "test"',
|
||||
workingDir: '/tmp',
|
||||
}),
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.sessionId).toBeDefined();
|
||||
// Note: success/failure depends on Claude actually running
|
||||
});
|
||||
|
||||
it('should use current directory when workingDir not provided', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/run`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
prompt: 'pwd',
|
||||
}),
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.sessionId).toBeDefined();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,262 @@
|
||||
import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
|
||||
import { WebServer } from '../src/web/server.js';
|
||||
import { existsSync, rmSync } from 'node:fs';
|
||||
import { join } from 'node:path';
|
||||
import { homedir } from 'node:os';
|
||||
|
||||
const TEST_PORT = 3120;
|
||||
const CASES_DIR = join(homedir(), 'claudeman-cases');
|
||||
|
||||
/**
|
||||
* Session Cleanup Tests
|
||||
*
|
||||
* Tests for automatic session cleanup and resource management
|
||||
*/
|
||||
describe('Session Cleanup', () => {
|
||||
let server: WebServer;
|
||||
let baseUrl: string;
|
||||
const createdCases: string[] = [];
|
||||
const createdSessions: string[] = [];
|
||||
|
||||
beforeAll(async () => {
|
||||
server = new WebServer(TEST_PORT);
|
||||
await server.start();
|
||||
baseUrl = `http://localhost:${TEST_PORT}`;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
// Cleanup all sessions
|
||||
for (const sessionId of createdSessions) {
|
||||
try {
|
||||
await fetch(`${baseUrl}/api/sessions/${sessionId}`, { method: 'DELETE' });
|
||||
} catch {}
|
||||
}
|
||||
// Cleanup all cases
|
||||
for (const caseName of createdCases) {
|
||||
const casePath = join(CASES_DIR, caseName);
|
||||
if (existsSync(casePath)) {
|
||||
rmSync(casePath, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
await server.stop();
|
||||
}, 60000);
|
||||
|
||||
describe('Session Deletion', () => {
|
||||
it('should properly stop and cleanup interactive session', async () => {
|
||||
const caseName = `cleanup-test-${Date.now()}`;
|
||||
createdCases.push(caseName);
|
||||
|
||||
// Create and start interactive session
|
||||
const quickStartRes = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName }),
|
||||
});
|
||||
const quickStartData = await quickStartRes.json();
|
||||
expect(quickStartData.success).toBe(true);
|
||||
|
||||
// Delete the session
|
||||
const deleteRes = await fetch(`${baseUrl}/api/sessions/${quickStartData.sessionId}`, {
|
||||
method: 'DELETE',
|
||||
});
|
||||
const deleteData = await deleteRes.json();
|
||||
expect(deleteData.success).toBe(true);
|
||||
|
||||
// Verify session is gone
|
||||
const getRes = await fetch(`${baseUrl}/api/sessions/${quickStartData.sessionId}`);
|
||||
const getData = await getRes.json();
|
||||
expect(getData.error).toBe('Session not found');
|
||||
});
|
||||
|
||||
it('should cleanup multiple sessions when deleted', async () => {
|
||||
const sessionIds: string[] = [];
|
||||
|
||||
// Create multiple sessions
|
||||
for (let i = 0; i < 3; i++) {
|
||||
const caseName = `multi-cleanup-${Date.now()}-${i}`;
|
||||
createdCases.push(caseName);
|
||||
|
||||
const res = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName }),
|
||||
});
|
||||
const data = await res.json();
|
||||
expect(data.success).toBe(true);
|
||||
sessionIds.push(data.sessionId);
|
||||
}
|
||||
|
||||
// Delete all sessions
|
||||
for (const id of sessionIds) {
|
||||
const deleteRes = await fetch(`${baseUrl}/api/sessions/${id}`, {
|
||||
method: 'DELETE',
|
||||
});
|
||||
const deleteData = await deleteRes.json();
|
||||
expect(deleteData.success).toBe(true);
|
||||
}
|
||||
|
||||
// Verify all sessions are gone
|
||||
const listRes = await fetch(`${baseUrl}/api/sessions`);
|
||||
const sessions = await listRes.json();
|
||||
for (const id of sessionIds) {
|
||||
expect(sessions.find((s: any) => s.id === id)).toBeUndefined();
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('Respawn Controller Cleanup', () => {
|
||||
it('should cleanup respawn controller when session is deleted', async () => {
|
||||
const caseName = `respawn-cleanup-${Date.now()}`;
|
||||
createdCases.push(caseName);
|
||||
|
||||
// Create session
|
||||
const sessionRes = await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ workingDir: '/tmp' }),
|
||||
});
|
||||
const sessionData = await sessionRes.json();
|
||||
expect(sessionData.success).toBe(true);
|
||||
|
||||
// Start interactive with respawn
|
||||
const interactiveRes = await fetch(`${baseUrl}/api/sessions/${sessionData.session.id}/interactive-respawn`, {
|
||||
method: 'POST',
|
||||
});
|
||||
const interactiveData = await interactiveRes.json();
|
||||
expect(interactiveData.success).toBe(true);
|
||||
|
||||
// Verify respawn is running
|
||||
const respawnRes = await fetch(`${baseUrl}/api/sessions/${sessionData.session.id}/respawn`);
|
||||
const respawnData = await respawnRes.json();
|
||||
expect(respawnData.enabled).toBe(true);
|
||||
|
||||
// Delete session
|
||||
await fetch(`${baseUrl}/api/sessions/${sessionData.session.id}`, {
|
||||
method: 'DELETE',
|
||||
});
|
||||
|
||||
// Wait for cleanup to complete (exit event handler)
|
||||
await new Promise(resolve => setTimeout(resolve, 500));
|
||||
|
||||
// Verify respawn controller is cleaned up (enabled: false when controller doesn't exist)
|
||||
const respawnAfterRes = await fetch(`${baseUrl}/api/sessions/${sessionData.session.id}/respawn`);
|
||||
const respawnAfterData = await respawnAfterRes.json();
|
||||
// The respawn endpoint returns enabled: false when there's no controller
|
||||
expect(respawnAfterData.enabled).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Scheduled Run Cleanup', () => {
|
||||
it('should properly stop scheduled run', async () => {
|
||||
// Create a scheduled run
|
||||
const createRes = await fetch(`${baseUrl}/api/scheduled`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({
|
||||
prompt: 'test cleanup',
|
||||
workingDir: '/tmp',
|
||||
durationMinutes: 1,
|
||||
}),
|
||||
});
|
||||
const createData = await createRes.json();
|
||||
expect(createData.success).toBe(true);
|
||||
|
||||
// Stop the scheduled run
|
||||
const stopRes = await fetch(`${baseUrl}/api/scheduled/${createData.run.id}`, {
|
||||
method: 'DELETE',
|
||||
});
|
||||
const stopData = await stopRes.json();
|
||||
expect(stopData.success).toBe(true);
|
||||
|
||||
// Verify status is stopped
|
||||
const getRes = await fetch(`${baseUrl}/api/scheduled/${createData.run.id}`);
|
||||
const getData = await getRes.json();
|
||||
expect(getData.status).toBe('stopped');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('Resource Management', () => {
|
||||
let server: WebServer;
|
||||
let baseUrl: string;
|
||||
const createdCases: string[] = [];
|
||||
|
||||
beforeAll(async () => {
|
||||
server = new WebServer(TEST_PORT + 1);
|
||||
await server.start();
|
||||
baseUrl = `http://localhost:${TEST_PORT + 1}`;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
for (const caseName of createdCases) {
|
||||
const casePath = join(CASES_DIR, caseName);
|
||||
if (existsSync(casePath)) {
|
||||
rmSync(casePath, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
await server.stop();
|
||||
}, 60000);
|
||||
|
||||
it('should handle rapid session creation and deletion', async () => {
|
||||
const iterations = 5;
|
||||
|
||||
for (let i = 0; i < iterations; i++) {
|
||||
const caseName = `rapid-${Date.now()}-${i}`;
|
||||
createdCases.push(caseName);
|
||||
|
||||
// Create
|
||||
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName }),
|
||||
});
|
||||
const createData = await createRes.json();
|
||||
expect(createData.success).toBe(true);
|
||||
|
||||
// Delete immediately
|
||||
const deleteRes = await fetch(`${baseUrl}/api/sessions/${createData.sessionId}`, {
|
||||
method: 'DELETE',
|
||||
});
|
||||
const deleteData = await deleteRes.json();
|
||||
expect(deleteData.success).toBe(true);
|
||||
}
|
||||
|
||||
// Verify no sessions remain
|
||||
const listRes = await fetch(`${baseUrl}/api/sessions`);
|
||||
const sessions = await listRes.json();
|
||||
expect(sessions.length).toBe(0);
|
||||
});
|
||||
|
||||
it('should clear terminal buffer after session stop', async () => {
|
||||
const caseName = `buffer-clear-${Date.now()}`;
|
||||
createdCases.push(caseName);
|
||||
|
||||
// Create session
|
||||
const createRes = await fetch(`${baseUrl}/api/quick-start`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ caseName }),
|
||||
});
|
||||
const createData = await createRes.json();
|
||||
expect(createData.success).toBe(true);
|
||||
|
||||
// Wait for some terminal output - Claude startup time can vary
|
||||
await new Promise(resolve => setTimeout(resolve, 2000));
|
||||
|
||||
// Get terminal buffer before stop - may or may not have content depending on timing
|
||||
const terminalRes = await fetch(`${baseUrl}/api/sessions/${createData.sessionId}/terminal`);
|
||||
const terminalData = await terminalRes.json();
|
||||
// Just verify the property exists
|
||||
expect(terminalData.terminalBuffer).toBeDefined();
|
||||
|
||||
// Delete session
|
||||
await fetch(`${baseUrl}/api/sessions/${createData.sessionId}`, {
|
||||
method: 'DELETE',
|
||||
});
|
||||
|
||||
// Session should be gone
|
||||
const afterRes = await fetch(`${baseUrl}/api/sessions/${createData.sessionId}/terminal`);
|
||||
const afterData = await afterRes.json();
|
||||
expect(afterData.error).toBe('Session not found');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,241 @@
|
||||
import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
|
||||
import { WebServer } from '../src/web/server.js';
|
||||
|
||||
const TEST_PORT = 3102;
|
||||
|
||||
describe('Interactive Session Lifecycle', () => {
|
||||
let server: WebServer;
|
||||
let baseUrl: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = new WebServer(TEST_PORT);
|
||||
await server.start();
|
||||
baseUrl = `http://localhost:${TEST_PORT}`;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.stop();
|
||||
});
|
||||
|
||||
describe('Session Creation', () => {
|
||||
it('should create session with default working directory', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({}),
|
||||
});
|
||||
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(true);
|
||||
expect(data.session.id).toBeDefined();
|
||||
expect(data.session.workingDir).toBeDefined();
|
||||
expect(data.session.status).toBe('idle');
|
||||
});
|
||||
|
||||
it('should create session with custom working directory', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ workingDir: '/tmp/test' }),
|
||||
});
|
||||
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(true);
|
||||
expect(data.session.workingDir).toBe('/tmp/test');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Session Retrieval', () => {
|
||||
it('should get session by id', async () => {
|
||||
// Create a session first
|
||||
const createRes = await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({}),
|
||||
});
|
||||
const createData = await createRes.json();
|
||||
const sessionId = createData.session.id;
|
||||
|
||||
// Get the session
|
||||
const response = await fetch(`${baseUrl}/api/sessions/${sessionId}`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.id).toBe(sessionId);
|
||||
expect(data.status).toBeDefined();
|
||||
});
|
||||
|
||||
it('should return error for non-existent session', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions/non-existent-id`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.error).toBe('Session not found');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Session Deletion', () => {
|
||||
it('should delete a session', async () => {
|
||||
// Create a session first
|
||||
const createRes = await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({}),
|
||||
});
|
||||
const createData = await createRes.json();
|
||||
const sessionId = createData.session.id;
|
||||
|
||||
// Delete the session
|
||||
const response = await fetch(`${baseUrl}/api/sessions/${sessionId}`, {
|
||||
method: 'DELETE',
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(true);
|
||||
|
||||
// Verify it's gone
|
||||
const getRes = await fetch(`${baseUrl}/api/sessions/${sessionId}`);
|
||||
const getData = await getRes.json();
|
||||
expect(getData.error).toBe('Session not found');
|
||||
});
|
||||
|
||||
it('should return error when deleting non-existent session', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions/non-existent-id`, {
|
||||
method: 'DELETE',
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(false);
|
||||
expect(data.error).toBe('Session not found');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Session Output', () => {
|
||||
it('should get session output buffer', async () => {
|
||||
// Create a session first
|
||||
const createRes = await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({}),
|
||||
});
|
||||
const createData = await createRes.json();
|
||||
const sessionId = createData.session.id;
|
||||
|
||||
// Get output
|
||||
const response = await fetch(`${baseUrl}/api/sessions/${sessionId}/output`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(data).toHaveProperty('textOutput');
|
||||
expect(data).toHaveProperty('messages');
|
||||
expect(data).toHaveProperty('errorBuffer');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Session Terminal Buffer', () => {
|
||||
it('should get session terminal buffer', async () => {
|
||||
// Create a session first
|
||||
const createRes = await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({}),
|
||||
});
|
||||
const createData = await createRes.json();
|
||||
const sessionId = createData.session.id;
|
||||
|
||||
// Get terminal buffer
|
||||
const response = await fetch(`${baseUrl}/api/sessions/${sessionId}/terminal`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(data).toHaveProperty('terminalBuffer');
|
||||
expect(data).toHaveProperty('status');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Interactive Mode', () => {
|
||||
it('should start interactive session', async () => {
|
||||
// Create a session first
|
||||
const createRes = await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({}),
|
||||
});
|
||||
const createData = await createRes.json();
|
||||
const sessionId = createData.session.id;
|
||||
|
||||
// Start interactive mode
|
||||
const response = await fetch(`${baseUrl}/api/sessions/${sessionId}/interactive`, {
|
||||
method: 'POST',
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(true);
|
||||
expect(data.message).toBe('Interactive session started');
|
||||
});
|
||||
|
||||
it('should return error for non-existent session', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/sessions/non-existent/interactive`, {
|
||||
method: 'POST',
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.error).toBe('Session not found');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Session Input', () => {
|
||||
it('should send input to interactive session', async () => {
|
||||
// Create and start interactive session
|
||||
const createRes = await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({}),
|
||||
});
|
||||
const createData = await createRes.json();
|
||||
const sessionId = createData.session.id;
|
||||
|
||||
await fetch(`${baseUrl}/api/sessions/${sessionId}/interactive`, {
|
||||
method: 'POST',
|
||||
});
|
||||
|
||||
// Wait a bit for interactive session to start
|
||||
await new Promise(resolve => setTimeout(resolve, 500));
|
||||
|
||||
// Send input
|
||||
const response = await fetch(`${baseUrl}/api/sessions/${sessionId}/input`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ input: 'test input\n' }),
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Session Resize', () => {
|
||||
it('should resize session terminal', async () => {
|
||||
// Create and start interactive session
|
||||
const createRes = await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({}),
|
||||
});
|
||||
const createData = await createRes.json();
|
||||
const sessionId = createData.session.id;
|
||||
|
||||
await fetch(`${baseUrl}/api/sessions/${sessionId}/interactive`, {
|
||||
method: 'POST',
|
||||
});
|
||||
|
||||
// Resize
|
||||
const response = await fetch(`${baseUrl}/api/sessions/${sessionId}/resize`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ cols: 120, rows: 40 }),
|
||||
});
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.success).toBe(true);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,300 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
||||
import { WebServer } from '../src/web/server.js';
|
||||
import { EventEmitter } from 'node:events';
|
||||
|
||||
const TEST_PORT = 3107;
|
||||
|
||||
// Helper to parse SSE events
|
||||
function parseSSEEvents(text: string): Array<{ event: string; data: unknown }> {
|
||||
const events: Array<{ event: string; data: unknown }> = [];
|
||||
const lines = text.split('\n');
|
||||
let currentEvent = '';
|
||||
let currentData = '';
|
||||
|
||||
for (const line of lines) {
|
||||
if (line.startsWith('event: ')) {
|
||||
currentEvent = line.substring(7);
|
||||
} else if (line.startsWith('data: ')) {
|
||||
currentData = line.substring(6);
|
||||
} else if (line === '') {
|
||||
if (currentEvent && currentData) {
|
||||
try {
|
||||
events.push({ event: currentEvent, data: JSON.parse(currentData) });
|
||||
} catch {
|
||||
events.push({ event: currentEvent, data: currentData });
|
||||
}
|
||||
}
|
||||
currentEvent = '';
|
||||
currentData = '';
|
||||
}
|
||||
}
|
||||
|
||||
return events;
|
||||
}
|
||||
|
||||
describe('SSE Events', () => {
|
||||
let server: WebServer;
|
||||
let baseUrl: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = new WebServer(TEST_PORT);
|
||||
await server.start();
|
||||
baseUrl = `http://localhost:${TEST_PORT}`;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.stop();
|
||||
}, 60000);
|
||||
|
||||
describe('GET /api/events', () => {
|
||||
it('should return text/event-stream content type', async () => {
|
||||
const controller = new AbortController();
|
||||
const timeout = setTimeout(() => controller.abort(), 1000);
|
||||
|
||||
try {
|
||||
const response = await fetch(`${baseUrl}/api/events`, {
|
||||
signal: controller.signal,
|
||||
});
|
||||
|
||||
expect(response.headers.get('content-type')).toBe('text/event-stream');
|
||||
} catch (err: any) {
|
||||
// AbortError is expected
|
||||
if (err.name !== 'AbortError') throw err;
|
||||
} finally {
|
||||
clearTimeout(timeout);
|
||||
}
|
||||
});
|
||||
|
||||
it('should send init event on connection', async () => {
|
||||
const controller = new AbortController();
|
||||
|
||||
// Collect data for a short time
|
||||
let receivedData = '';
|
||||
const timeout = setTimeout(() => controller.abort(), 500);
|
||||
|
||||
try {
|
||||
const response = await fetch(`${baseUrl}/api/events`, {
|
||||
signal: controller.signal,
|
||||
});
|
||||
|
||||
const reader = response.body?.getReader();
|
||||
if (reader) {
|
||||
while (true) {
|
||||
const { done, value } = await reader.read();
|
||||
if (done) break;
|
||||
receivedData += new TextDecoder().decode(value);
|
||||
}
|
||||
}
|
||||
} catch (err: any) {
|
||||
if (err.name !== 'AbortError') throw err;
|
||||
} finally {
|
||||
clearTimeout(timeout);
|
||||
}
|
||||
|
||||
// Parse and check for init event
|
||||
const events = parseSSEEvents(receivedData);
|
||||
const initEvent = events.find(e => e.event === 'init');
|
||||
|
||||
expect(initEvent).toBeDefined();
|
||||
expect((initEvent?.data as any).sessions).toBeDefined();
|
||||
expect((initEvent?.data as any).scheduledRuns).toBeDefined();
|
||||
expect((initEvent?.data as any).respawnStatus).toBeDefined();
|
||||
expect((initEvent?.data as any).timestamp).toBeDefined();
|
||||
});
|
||||
|
||||
it('should receive session:created event when session is created', async () => {
|
||||
const controller = new AbortController();
|
||||
let receivedData = '';
|
||||
|
||||
// Start listening
|
||||
const fetchPromise = fetch(`${baseUrl}/api/events`, {
|
||||
signal: controller.signal,
|
||||
}).then(async response => {
|
||||
const reader = response.body?.getReader();
|
||||
if (reader) {
|
||||
try {
|
||||
while (true) {
|
||||
const { done, value } = await reader.read();
|
||||
if (done) break;
|
||||
receivedData += new TextDecoder().decode(value);
|
||||
}
|
||||
} catch {}
|
||||
}
|
||||
});
|
||||
|
||||
// Give time to connect
|
||||
await new Promise(resolve => setTimeout(resolve, 100));
|
||||
|
||||
// Create a session
|
||||
await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ workingDir: '/tmp' }),
|
||||
});
|
||||
|
||||
// Wait a bit for the event
|
||||
await new Promise(resolve => setTimeout(resolve, 200));
|
||||
|
||||
// Stop listening
|
||||
controller.abort();
|
||||
try { await fetchPromise; } catch {}
|
||||
|
||||
// Parse events
|
||||
const events = parseSSEEvents(receivedData);
|
||||
const sessionCreated = events.find(e => e.event === 'session:created');
|
||||
|
||||
expect(sessionCreated).toBeDefined();
|
||||
expect((sessionCreated?.data as any).id).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('GET /api/status', () => {
|
||||
it('should return full state', async () => {
|
||||
const response = await fetch(`${baseUrl}/api/status`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(data).toHaveProperty('sessions');
|
||||
expect(data).toHaveProperty('scheduledRuns');
|
||||
expect(data).toHaveProperty('respawnStatus');
|
||||
expect(data).toHaveProperty('timestamp');
|
||||
});
|
||||
|
||||
it('should include active sessions', async () => {
|
||||
// Create a session first
|
||||
await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ workingDir: '/tmp' }),
|
||||
});
|
||||
|
||||
const response = await fetch(`${baseUrl}/api/status`);
|
||||
const data = await response.json();
|
||||
|
||||
expect(data.sessions.length).toBeGreaterThan(0);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('SSE Event Types', () => {
|
||||
let server: WebServer;
|
||||
let baseUrl: string;
|
||||
|
||||
beforeAll(async () => {
|
||||
server = new WebServer(TEST_PORT + 1);
|
||||
await server.start();
|
||||
baseUrl = `http://localhost:${TEST_PORT + 1}`;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await server.stop();
|
||||
}, 60000);
|
||||
|
||||
describe('Session Events', () => {
|
||||
it('should emit session:deleted when session is deleted', async () => {
|
||||
const controller = new AbortController();
|
||||
let receivedData = '';
|
||||
|
||||
// Start listening
|
||||
const fetchPromise = fetch(`${baseUrl}/api/events`, {
|
||||
signal: controller.signal,
|
||||
}).then(async response => {
|
||||
const reader = response.body?.getReader();
|
||||
if (reader) {
|
||||
try {
|
||||
while (true) {
|
||||
const { done, value } = await reader.read();
|
||||
if (done) break;
|
||||
receivedData += new TextDecoder().decode(value);
|
||||
}
|
||||
} catch {}
|
||||
}
|
||||
});
|
||||
|
||||
// Give time to connect
|
||||
await new Promise(resolve => setTimeout(resolve, 100));
|
||||
|
||||
// Create a session
|
||||
const createRes = await fetch(`${baseUrl}/api/sessions`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ workingDir: '/tmp' }),
|
||||
});
|
||||
const createData = await createRes.json();
|
||||
|
||||
// Delete it
|
||||
await fetch(`${baseUrl}/api/sessions/${createData.session.id}`, {
|
||||
method: 'DELETE',
|
||||
});
|
||||
|
||||
// Wait for events
|
||||
await new Promise(resolve => setTimeout(resolve, 200));
|
||||
|
||||
// Stop listening
|
||||
controller.abort();
|
||||
try { await fetchPromise; } catch {}
|
||||
|
||||
// Parse events
|
||||
const events = parseSSEEvents(receivedData);
|
||||
const sessionDeleted = events.find(e => e.event === 'session:deleted');
|
||||
|
||||
expect(sessionDeleted).toBeDefined();
|
||||
expect((sessionDeleted?.data as any).id).toBe(createData.session.id);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Case Events', () => {
|
||||
it('should emit case:created when case is created', async () => {
|
||||
const controller = new AbortController();
|
||||
let receivedData = '';
|
||||
|
||||
// Start listening
|
||||
const fetchPromise = fetch(`${baseUrl}/api/events`, {
|
||||
signal: controller.signal,
|
||||
}).then(async response => {
|
||||
const reader = response.body?.getReader();
|
||||
if (reader) {
|
||||
try {
|
||||
while (true) {
|
||||
const { done, value } = await reader.read();
|
||||
if (done) break;
|
||||
receivedData += new TextDecoder().decode(value);
|
||||
}
|
||||
} catch {}
|
||||
}
|
||||
});
|
||||
|
||||
// Give time to connect
|
||||
await new Promise(resolve => setTimeout(resolve, 100));
|
||||
|
||||
// Create a case
|
||||
const caseName = `test-sse-case-${Date.now()}`;
|
||||
await fetch(`${baseUrl}/api/cases`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ name: caseName }),
|
||||
});
|
||||
|
||||
// Wait for events
|
||||
await new Promise(resolve => setTimeout(resolve, 200));
|
||||
|
||||
// Stop listening
|
||||
controller.abort();
|
||||
try { await fetchPromise; } catch {}
|
||||
|
||||
// Parse events
|
||||
const events = parseSSEEvents(receivedData);
|
||||
const caseCreated = events.find(e => e.event === 'case:created');
|
||||
|
||||
expect(caseCreated).toBeDefined();
|
||||
expect((caseCreated?.data as any).name).toBe(caseName);
|
||||
|
||||
// Cleanup
|
||||
const { rmSync } = await import('node:fs');
|
||||
const { join } = await import('node:path');
|
||||
const { homedir } = await import('node:os');
|
||||
try {
|
||||
rmSync(join(homedir(), 'claudeman-cases', caseName), { recursive: true });
|
||||
} catch {}
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,16 @@
|
||||
import { defineConfig } from 'vitest/config';
|
||||
|
||||
export default defineConfig({
|
||||
test: {
|
||||
globals: true,
|
||||
environment: 'node',
|
||||
include: ['test/**/*.test.ts'],
|
||||
coverage: {
|
||||
provider: 'v8',
|
||||
reporter: ['text', 'json', 'html'],
|
||||
include: ['src/**/*.ts'],
|
||||
exclude: ['src/index.ts', 'src/cli.ts'],
|
||||
},
|
||||
testTimeout: 30000, // 30 seconds for integration tests
|
||||
},
|
||||
});
|
||||
Reference in New Issue
Block a user