d4a28713f6
- Remove original task blocking in handleConflict (task is already completed by handleAgentStopped) - Return created conflict task from handleConflict so orchestrator can queue it for dispatch - Add dedup check to prevent duplicate resolution tasks on crash retries - Queue conflict resolution task via dispatchManager in mergeTaskIntoPhase - Add recovery for erroneously blocked tasks in recoverDispatchQueues - Update tests and docs
428 lines
15 KiB
TypeScript
428 lines
15 KiB
TypeScript
/**
|
|
* E2E Tests for Edge Cases
|
|
*
|
|
* Tests edge case scenarios in dispatch/coordination flow:
|
|
* - Agent crashes during task
|
|
* - Agent waiting for input
|
|
* - Task blocking
|
|
* - Merge conflicts
|
|
*
|
|
* Uses TestHarness from src/test/ for full system wiring.
|
|
*/
|
|
|
|
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
|
|
import {
|
|
createTestHarness,
|
|
SIMPLE_FIXTURE,
|
|
type TestHarness,
|
|
} from '../index.js';
|
|
import type {
|
|
AgentSpawnedEvent,
|
|
AgentCrashedEvent,
|
|
AgentWaitingEvent,
|
|
TaskBlockedEvent,
|
|
MergeConflictedEvent,
|
|
} from '../../events/types.js';
|
|
|
|
describe('E2E Edge Cases', () => {
|
|
let harness: TestHarness;
|
|
|
|
beforeEach(() => {
|
|
harness = createTestHarness();
|
|
});
|
|
|
|
afterEach(() => {
|
|
harness.cleanup();
|
|
vi.useRealTimers();
|
|
});
|
|
|
|
describe('Agent crash during task', () => {
|
|
it('emits agent:spawned then agent:crashed events', async () => {
|
|
vi.useFakeTimers();
|
|
const seeded = await harness.seedFixture(SIMPLE_FIXTURE);
|
|
const taskAId = seeded.tasks.get('Task A')!;
|
|
|
|
// Pre-seed required idle agent for DispatchManager
|
|
await harness.agentManager.spawn({
|
|
name: 'pool-agent',
|
|
taskId: 'placeholder',
|
|
prompt: 'placeholder',
|
|
});
|
|
await harness.advanceTimers();
|
|
|
|
// Set error scenario BEFORE dispatch
|
|
harness.setAgentScenario(`agent-${taskAId.slice(0, 6)}`, {
|
|
status: 'error',
|
|
error: 'Token limit exceeded',
|
|
});
|
|
|
|
await harness.dispatchManager.queue(taskAId);
|
|
harness.clearEvents();
|
|
|
|
await harness.dispatchManager.dispatchNext();
|
|
await harness.advanceTimers();
|
|
|
|
// Verify: agent:spawned event emitted
|
|
const spawnedEvents = harness.getEventsByType('agent:spawned');
|
|
expect(spawnedEvents.length).toBe(1);
|
|
const spawnedPayload = (spawnedEvents[0] as AgentSpawnedEvent).payload;
|
|
expect(spawnedPayload.taskId).toBe(taskAId);
|
|
|
|
// Verify: agent:crashed event emitted
|
|
const crashedEvents = harness.getEventsByType('agent:crashed');
|
|
expect(crashedEvents.length).toBe(1);
|
|
const crashedPayload = (crashedEvents[0] as AgentCrashedEvent).payload;
|
|
expect(crashedPayload.taskId).toBe(taskAId);
|
|
expect(crashedPayload.error).toBe('Token limit exceeded');
|
|
});
|
|
|
|
it('task status should NOT be completed after crash', async () => {
|
|
vi.useFakeTimers();
|
|
const seeded = await harness.seedFixture(SIMPLE_FIXTURE);
|
|
const taskAId = seeded.tasks.get('Task A')!;
|
|
|
|
// Pre-seed required idle agent
|
|
await harness.agentManager.spawn({
|
|
name: 'pool-agent',
|
|
taskId: 'placeholder',
|
|
prompt: 'placeholder',
|
|
});
|
|
await harness.advanceTimers();
|
|
|
|
// Set error scenario
|
|
harness.setAgentScenario(`agent-${taskAId.slice(0, 6)}`, {
|
|
status: 'error',
|
|
error: 'Token limit exceeded',
|
|
});
|
|
|
|
await harness.dispatchManager.queue(taskAId);
|
|
await harness.dispatchManager.dispatchNext();
|
|
await harness.advanceTimers();
|
|
|
|
// Task status should be 'in_progress' (not 'completed')
|
|
const task = await harness.taskRepository.findById(taskAId);
|
|
expect(task?.status).toBe('in_progress');
|
|
});
|
|
|
|
it('captures error message in agent result', async () => {
|
|
vi.useFakeTimers();
|
|
const seeded = await harness.seedFixture(SIMPLE_FIXTURE);
|
|
const taskAId = seeded.tasks.get('Task A')!;
|
|
|
|
// Pre-seed required idle agent
|
|
await harness.agentManager.spawn({
|
|
name: 'pool-agent',
|
|
taskId: 'placeholder',
|
|
prompt: 'placeholder',
|
|
});
|
|
await harness.advanceTimers();
|
|
|
|
// Set error scenario
|
|
harness.setAgentScenario(`agent-${taskAId.slice(0, 6)}`, {
|
|
status: 'error',
|
|
error: 'Out of memory',
|
|
});
|
|
|
|
await harness.dispatchManager.queue(taskAId);
|
|
const dispatchResult = await harness.dispatchManager.dispatchNext();
|
|
await harness.advanceTimers();
|
|
|
|
// Get agent result - should have error
|
|
const agentResult = await harness.agentManager.getResult(dispatchResult.agentId!);
|
|
expect(agentResult).not.toBeNull();
|
|
expect(agentResult?.success).toBe(false);
|
|
expect(agentResult?.message).toBe('Out of memory');
|
|
});
|
|
});
|
|
|
|
describe('Agent waiting for input and resume', () => {
|
|
it('emits agent:waiting event with question', async () => {
|
|
vi.useFakeTimers();
|
|
const seeded = await harness.seedFixture(SIMPLE_FIXTURE);
|
|
const taskAId = seeded.tasks.get('Task A')!;
|
|
|
|
// Pre-seed required idle agent
|
|
await harness.agentManager.spawn({
|
|
name: 'pool-agent',
|
|
taskId: 'placeholder',
|
|
prompt: 'placeholder',
|
|
});
|
|
await harness.advanceTimers();
|
|
|
|
// Set questions scenario
|
|
harness.setAgentScenario(`agent-${taskAId.slice(0, 6)}`, {
|
|
status: 'questions',
|
|
questions: [{ id: 'q1', question: 'Which database should I use?' }],
|
|
});
|
|
|
|
await harness.dispatchManager.queue(taskAId);
|
|
harness.clearEvents();
|
|
|
|
await harness.dispatchManager.dispatchNext();
|
|
await harness.advanceTimers();
|
|
|
|
// Verify: agent:waiting event emitted
|
|
const waitingEvents = harness.getEventsByType('agent:waiting');
|
|
expect(waitingEvents.length).toBe(1);
|
|
const waitingPayload = (waitingEvents[0] as AgentWaitingEvent).payload;
|
|
expect(waitingPayload.taskId).toBe(taskAId);
|
|
expect(waitingPayload.questions[0].question).toBe('Which database should I use?');
|
|
});
|
|
|
|
});
|
|
|
|
describe('Task blocking', () => {
|
|
it('blocked task appears in blocked list from getQueueState', async () => {
|
|
const seeded = await harness.seedFixture(SIMPLE_FIXTURE);
|
|
const taskAId = seeded.tasks.get('Task A')!;
|
|
|
|
await harness.dispatchManager.queue(taskAId);
|
|
await harness.dispatchManager.blockTask(taskAId, 'Waiting for user decision');
|
|
|
|
const queueState = await harness.dispatchManager.getQueueState();
|
|
|
|
expect(queueState.blocked.length).toBe(1);
|
|
expect(queueState.blocked[0].taskId).toBe(taskAId);
|
|
expect(queueState.blocked[0].reason).toBe('Waiting for user decision');
|
|
});
|
|
|
|
it('blocked task emits task:blocked event', async () => {
|
|
const seeded = await harness.seedFixture(SIMPLE_FIXTURE);
|
|
const taskAId = seeded.tasks.get('Task A')!;
|
|
|
|
await harness.dispatchManager.queue(taskAId);
|
|
harness.clearEvents();
|
|
|
|
await harness.dispatchManager.blockTask(taskAId, 'Waiting for user decision');
|
|
|
|
const blockedEvents = harness.getEventsByType('task:blocked');
|
|
expect(blockedEvents.length).toBe(1);
|
|
const blockedPayload = (blockedEvents[0] as TaskBlockedEvent).payload;
|
|
expect(blockedPayload.taskId).toBe(taskAId);
|
|
expect(blockedPayload.reason).toBe('Waiting for user decision');
|
|
});
|
|
|
|
it('getNextDispatchable does not return blocked task', async () => {
|
|
vi.useFakeTimers();
|
|
const seeded = await harness.seedFixture(SIMPLE_FIXTURE);
|
|
const taskAId = seeded.tasks.get('Task A')!;
|
|
const taskBId = seeded.tasks.get('Task B')!;
|
|
|
|
// Pre-seed required idle agent
|
|
await harness.agentManager.spawn({
|
|
name: 'pool-agent',
|
|
taskId: 'placeholder',
|
|
prompt: 'placeholder',
|
|
});
|
|
await harness.advanceTimers();
|
|
|
|
// Queue Task A and block it
|
|
await harness.dispatchManager.queue(taskAId);
|
|
await harness.dispatchManager.blockTask(taskAId, 'Blocked for testing');
|
|
|
|
// Queue Task B (not blocked, but depends on Task A which needs to be completed first)
|
|
// Actually Task B depends on Task A in SIMPLE_FIXTURE, but the dependency
|
|
// isn't loaded into the queue. Queue a fresh task instead.
|
|
// For this test, we just verify blocked task is not returned.
|
|
|
|
// Get next dispatchable - should be null since Task A is blocked
|
|
const next = await harness.dispatchManager.getNextDispatchable();
|
|
expect(next).toBeNull();
|
|
});
|
|
|
|
it('task status is set to blocked in database', async () => {
|
|
const seeded = await harness.seedFixture(SIMPLE_FIXTURE);
|
|
const taskAId = seeded.tasks.get('Task A')!;
|
|
|
|
await harness.dispatchManager.queue(taskAId);
|
|
await harness.dispatchManager.blockTask(taskAId, 'Blocked for testing');
|
|
|
|
const task = await harness.taskRepository.findById(taskAId);
|
|
expect(task?.status).toBe('blocked');
|
|
});
|
|
});
|
|
|
|
describe('Merge conflict handling', () => {
|
|
it('detects merge conflict and emits merge:conflicted event', async () => {
|
|
const seeded = await harness.seedFixture(SIMPLE_FIXTURE);
|
|
const taskAId = seeded.tasks.get('Task A')!;
|
|
|
|
// Mark task as completed (required for merge)
|
|
await harness.taskRepository.update(taskAId, { status: 'completed' });
|
|
|
|
// Create a worktree for this task
|
|
const worktreeId = `wt-${taskAId.slice(0, 6)}`;
|
|
await harness.worktreeManager.create(worktreeId, 'feature-task-a');
|
|
|
|
// Create agent in agentRepository with worktreeId
|
|
// (coordinationManager.queueMerge looks up agent by taskId)
|
|
const agent = await harness.agentRepository.create({
|
|
name: `agent-${taskAId.slice(0, 6)}`,
|
|
worktreeId,
|
|
taskId: taskAId,
|
|
status: 'idle',
|
|
});
|
|
|
|
// Set up merge conflict result BEFORE processMerges
|
|
harness.worktreeManager.setMergeResult(worktreeId, {
|
|
success: false,
|
|
conflicts: ['src/shared.ts', 'src/types.ts'],
|
|
message: 'Merge conflict in 2 files',
|
|
});
|
|
|
|
// Queue for merge
|
|
await harness.coordinationManager.queueMerge(taskAId);
|
|
harness.clearEvents();
|
|
|
|
// Process merges - should hit conflict
|
|
const results = await harness.coordinationManager.processMerges('main');
|
|
|
|
// Verify: merge result indicates failure
|
|
expect(results.length).toBe(1);
|
|
expect(results[0].success).toBe(false);
|
|
expect(results[0].conflicts).toEqual(['src/shared.ts', 'src/types.ts']);
|
|
|
|
// Verify: merge:conflicted event emitted
|
|
const conflictEvents = harness.getEventsByType('merge:conflicted');
|
|
expect(conflictEvents.length).toBe(1);
|
|
const conflictPayload = (conflictEvents[0] as MergeConflictedEvent).payload;
|
|
expect(conflictPayload.taskId).toBe(taskAId);
|
|
expect(conflictPayload.conflictingFiles).toEqual(['src/shared.ts', 'src/types.ts']);
|
|
});
|
|
|
|
it('conflict appears in queue state as conflicted', async () => {
|
|
const seeded = await harness.seedFixture(SIMPLE_FIXTURE);
|
|
const taskAId = seeded.tasks.get('Task A')!;
|
|
|
|
// Mark task as completed
|
|
await harness.taskRepository.update(taskAId, { status: 'completed' });
|
|
|
|
// Create worktree
|
|
const worktreeId = `wt-${taskAId.slice(0, 6)}`;
|
|
await harness.worktreeManager.create(worktreeId, 'feature-task-a');
|
|
|
|
// Create agent in agentRepository
|
|
await harness.agentRepository.create({
|
|
name: `agent-${taskAId.slice(0, 6)}`,
|
|
worktreeId,
|
|
taskId: taskAId,
|
|
status: 'idle',
|
|
});
|
|
|
|
// Set up merge conflict
|
|
harness.worktreeManager.setMergeResult(worktreeId, {
|
|
success: false,
|
|
conflicts: ['src/shared.ts'],
|
|
message: 'Merge conflict',
|
|
});
|
|
|
|
// Queue and process
|
|
await harness.coordinationManager.queueMerge(taskAId);
|
|
await harness.coordinationManager.processMerges('main');
|
|
|
|
// Check queue state
|
|
const queueState = await harness.coordinationManager.getQueueState();
|
|
expect(queueState.conflicted.length).toBe(1);
|
|
expect(queueState.conflicted[0].taskId).toBe(taskAId);
|
|
expect(queueState.conflicted[0].conflicts).toContain('src/shared.ts');
|
|
});
|
|
|
|
it('handleConflict creates conflict-resolution task', async () => {
|
|
const seeded = await harness.seedFixture(SIMPLE_FIXTURE);
|
|
const taskAId = seeded.tasks.get('Task A')!;
|
|
|
|
// Mark task as completed
|
|
await harness.taskRepository.update(taskAId, { status: 'completed' });
|
|
|
|
// Create worktree
|
|
const worktreeId = `wt-${taskAId.slice(0, 6)}`;
|
|
await harness.worktreeManager.create(worktreeId, 'feature-task-a');
|
|
|
|
// Create agent in agentRepository
|
|
await harness.agentRepository.create({
|
|
name: `agent-${taskAId.slice(0, 6)}`,
|
|
worktreeId,
|
|
taskId: taskAId,
|
|
status: 'idle',
|
|
});
|
|
|
|
// Set up merge conflict
|
|
harness.worktreeManager.setMergeResult(worktreeId, {
|
|
success: false,
|
|
conflicts: ['src/shared.ts', 'src/types.ts'],
|
|
message: 'Merge conflict',
|
|
});
|
|
|
|
// Queue and process (handleConflict is called automatically)
|
|
await harness.coordinationManager.queueMerge(taskAId);
|
|
await harness.coordinationManager.processMerges('main');
|
|
|
|
// Verify: original task is NOT blocked (stays completed — the pending
|
|
// resolution task prevents premature phase completion)
|
|
const originalTask = await harness.taskRepository.findById(taskAId);
|
|
expect(originalTask?.status).toBe('completed');
|
|
|
|
// Verify: task:queued event emitted for conflict resolution task
|
|
const queuedEvents = harness.getEventsByType('task:queued');
|
|
const conflictTaskEvent = queuedEvents.find(
|
|
(e) => e.payload && (e.payload as { taskId: string }).taskId !== taskAId
|
|
);
|
|
expect(conflictTaskEvent).toBeDefined();
|
|
});
|
|
|
|
it('successful merge after clearing conflict result', async () => {
|
|
const seeded = await harness.seedFixture(SIMPLE_FIXTURE);
|
|
const taskAId = seeded.tasks.get('Task A')!;
|
|
const taskBId = seeded.tasks.get('Task B')!;
|
|
|
|
// Set up Task A for merge (with conflict)
|
|
await harness.taskRepository.update(taskAId, { status: 'completed' });
|
|
const worktreeIdA = `wt-${taskAId.slice(0, 6)}`;
|
|
await harness.worktreeManager.create(worktreeIdA, 'feature-task-a');
|
|
await harness.agentRepository.create({
|
|
name: `agent-${taskAId.slice(0, 6)}`,
|
|
worktreeId: worktreeIdA,
|
|
taskId: taskAId,
|
|
status: 'idle',
|
|
});
|
|
|
|
// Set conflict for Task A
|
|
harness.worktreeManager.setMergeResult(worktreeIdA, {
|
|
success: false,
|
|
conflicts: ['src/shared.ts'],
|
|
message: 'Merge conflict',
|
|
});
|
|
|
|
// Process Task A merge (will conflict)
|
|
await harness.coordinationManager.queueMerge(taskAId);
|
|
const conflictResults = await harness.coordinationManager.processMerges('main');
|
|
expect(conflictResults[0].success).toBe(false);
|
|
|
|
// Now set up Task B for merge (should succeed)
|
|
await harness.taskRepository.update(taskBId, { status: 'completed' });
|
|
const worktreeIdB = `wt-${taskBId.slice(0, 6)}`;
|
|
await harness.worktreeManager.create(worktreeIdB, 'feature-task-b');
|
|
await harness.agentRepository.create({
|
|
name: `agent-${taskBId.slice(0, 6)}`,
|
|
worktreeId: worktreeIdB,
|
|
taskId: taskBId,
|
|
status: 'idle',
|
|
});
|
|
|
|
// Task B merge should succeed (default behavior)
|
|
await harness.coordinationManager.queueMerge(taskBId);
|
|
harness.clearEvents();
|
|
const successResults = await harness.coordinationManager.processMerges('main');
|
|
|
|
// Verify Task B merged successfully
|
|
expect(successResults.length).toBe(1);
|
|
expect(successResults[0].taskId).toBe(taskBId);
|
|
expect(successResults[0].success).toBe(true);
|
|
|
|
// Verify Task B in merged list
|
|
const queueState = await harness.coordinationManager.getQueueState();
|
|
expect(queueState.merged).toContain(taskBId);
|
|
});
|
|
});
|
|
});
|