34578d39c6
Move src/ → apps/server/ and packages/web/ → apps/web/ to adopt standard monorepo conventions (apps/ for runnable apps, packages/ for reusable libraries). Update all config files, shared package imports, test fixtures, and documentation to reflect new paths. Key fixes: - Update workspace config to ["apps/*", "packages/*"] - Update tsconfig.json rootDir/include for apps/server/ - Add apps/web/** to vitest exclude list - Update drizzle.config.ts schema path - Fix ensure-schema.ts migration path detection (3 levels up in dev, 2 levels up in dist) - Fix tests/integration/cli-server.test.ts import paths - Update packages/shared imports to apps/server/ paths - Update all docs/ files with new paths
694 lines
21 KiB
TypeScript
694 lines
21 KiB
TypeScript
/**
|
|
* DefaultCoordinationManager Tests
|
|
*
|
|
* Tests for the CoordinationManager adapter with dependency-ordered
|
|
* merging and conflict handling.
|
|
*/
|
|
|
|
import { describe, it, expect, beforeEach, vi } from 'vitest';
|
|
import { DefaultCoordinationManager } from './manager.js';
|
|
import { DrizzleTaskRepository } from '../db/repositories/drizzle/task.js';
|
|
import { DrizzleAgentRepository } from '../db/repositories/drizzle/agent.js';
|
|
import { DrizzleMessageRepository } from '../db/repositories/drizzle/message.js';
|
|
|
|
import { DrizzlePhaseRepository } from '../db/repositories/drizzle/phase.js';
|
|
import { DrizzleInitiativeRepository } from '../db/repositories/drizzle/initiative.js';
|
|
import { createTestDatabase } from '../db/repositories/drizzle/test-helpers.js';
|
|
import type { DrizzleDatabase } from '../db/index.js';
|
|
import type { EventBus, DomainEvent } from '../events/types.js';
|
|
import type { WorktreeManager, MergeResult as GitMergeResult } from '../git/types.js';
|
|
import type { TaskRepository } from '../db/repositories/task-repository.js';
|
|
import type { AgentRepository } from '../db/repositories/agent-repository.js';
|
|
import type { MessageRepository } from '../db/repositories/message-repository.js';
|
|
import type { ConflictResolutionService } from './conflict-resolution-service.js';
|
|
|
|
// =============================================================================
|
|
// Test Helpers
|
|
// =============================================================================
|
|
|
|
/**
|
|
* Create a mock EventBus that captures emitted events.
|
|
*/
|
|
function createMockEventBus(): EventBus & { emittedEvents: DomainEvent[] } {
|
|
const emittedEvents: DomainEvent[] = [];
|
|
|
|
return {
|
|
emittedEvents,
|
|
emit<T extends DomainEvent>(event: T): void {
|
|
emittedEvents.push(event);
|
|
},
|
|
on: vi.fn(),
|
|
off: vi.fn(),
|
|
once: vi.fn(),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Create a mock WorktreeManager with configurable merge results.
|
|
*/
|
|
function createMockWorktreeManager(
|
|
mergeResults: Map<string, GitMergeResult> = new Map()
|
|
): WorktreeManager {
|
|
return {
|
|
create: vi.fn(),
|
|
remove: vi.fn(),
|
|
list: vi.fn().mockResolvedValue([]),
|
|
get: vi.fn(),
|
|
diff: vi.fn(),
|
|
merge: vi.fn().mockImplementation(async (worktreeId: string) => {
|
|
const result = mergeResults.get(worktreeId);
|
|
if (result) return result;
|
|
// Default: successful merge
|
|
return { success: true, message: 'Merged successfully' };
|
|
}),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Create a mock ConflictResolutionService.
|
|
*/
|
|
function createMockConflictResolutionService(): ConflictResolutionService {
|
|
return {
|
|
handleConflict: vi.fn(),
|
|
};
|
|
}
|
|
|
|
// =============================================================================
|
|
// Tests
|
|
// =============================================================================
|
|
|
|
describe('DefaultCoordinationManager', () => {
|
|
let db: DrizzleDatabase;
|
|
let taskRepository: TaskRepository;
|
|
let agentRepository: AgentRepository;
|
|
let messageRepository: MessageRepository;
|
|
let eventBus: EventBus & { emittedEvents: DomainEvent[] };
|
|
let worktreeManager: WorktreeManager;
|
|
let conflictResolutionService: ConflictResolutionService;
|
|
let manager: DefaultCoordinationManager;
|
|
let testPhaseId: string;
|
|
|
|
beforeEach(async () => {
|
|
// Set up test database
|
|
db = createTestDatabase();
|
|
taskRepository = new DrizzleTaskRepository(db);
|
|
agentRepository = new DrizzleAgentRepository(db);
|
|
messageRepository = new DrizzleMessageRepository(db);
|
|
|
|
// Create required hierarchy for tasks
|
|
const initiativeRepo = new DrizzleInitiativeRepository(db);
|
|
const phaseRepo = new DrizzlePhaseRepository(db);
|
|
|
|
const initiative = await initiativeRepo.create({
|
|
name: 'Test Initiative',
|
|
});
|
|
const phase = await phaseRepo.create({
|
|
initiativeId: initiative.id,
|
|
name: 'Test Phase',
|
|
});
|
|
testPhaseId = phase.id;
|
|
|
|
// Create mocks
|
|
eventBus = createMockEventBus();
|
|
worktreeManager = createMockWorktreeManager();
|
|
|
|
// Create coordination manager
|
|
manager = new DefaultCoordinationManager(
|
|
worktreeManager,
|
|
taskRepository,
|
|
agentRepository,
|
|
messageRepository,
|
|
eventBus
|
|
);
|
|
});
|
|
|
|
// ===========================================================================
|
|
// queueMerge() Tests
|
|
// ===========================================================================
|
|
|
|
describe('queueMerge', () => {
|
|
it('should add task to queue and emit MergeQueuedEvent', async () => {
|
|
// Create task
|
|
const task = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'Test Task',
|
|
priority: 'high',
|
|
order: 1,
|
|
});
|
|
|
|
// Create agent for task
|
|
const agent = await agentRepository.create({
|
|
name: 'agent-test',
|
|
taskId: task.id,
|
|
worktreeId: 'worktree-123',
|
|
});
|
|
|
|
await manager.queueMerge(task.id);
|
|
|
|
const state = await manager.getQueueState();
|
|
expect(state.queued.length).toBe(1);
|
|
expect(state.queued[0].taskId).toBe(task.id);
|
|
expect(state.queued[0].agentId).toBe(agent.id);
|
|
expect(state.queued[0].worktreeId).toBe('worktree-123');
|
|
expect(state.queued[0].priority).toBe('high');
|
|
|
|
// Check event was emitted
|
|
expect(eventBus.emittedEvents.length).toBe(1);
|
|
expect(eventBus.emittedEvents[0].type).toBe('merge:queued');
|
|
expect((eventBus.emittedEvents[0] as any).payload.taskId).toBe(task.id);
|
|
});
|
|
|
|
it('should throw error when task not found', async () => {
|
|
await expect(manager.queueMerge('non-existent-id')).rejects.toThrow(
|
|
'Task not found'
|
|
);
|
|
});
|
|
|
|
it('should throw error when no agent assigned to task', async () => {
|
|
const task = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'Orphan Task',
|
|
order: 1,
|
|
});
|
|
|
|
await expect(manager.queueMerge(task.id)).rejects.toThrow(
|
|
'No agent found for task'
|
|
);
|
|
});
|
|
});
|
|
|
|
// ===========================================================================
|
|
// getNextMergeable() Tests
|
|
// ===========================================================================
|
|
|
|
describe('getNextMergeable', () => {
|
|
it('should return null when queue is empty', async () => {
|
|
const next = await manager.getNextMergeable();
|
|
expect(next).toBeNull();
|
|
});
|
|
|
|
it('should return item when all dependencies merged', async () => {
|
|
const task = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'Mergeable Task',
|
|
priority: 'medium',
|
|
order: 1,
|
|
});
|
|
|
|
await agentRepository.create({
|
|
name: 'agent-merge',
|
|
taskId: task.id,
|
|
worktreeId: 'worktree-merge',
|
|
});
|
|
|
|
await manager.queueMerge(task.id);
|
|
|
|
const next = await manager.getNextMergeable();
|
|
expect(next).not.toBeNull();
|
|
expect(next!.taskId).toBe(task.id);
|
|
});
|
|
|
|
it('should respect priority ordering (high > medium > low)', async () => {
|
|
// Create tasks in different priority order
|
|
const lowTask = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'Low Priority',
|
|
priority: 'low',
|
|
order: 1,
|
|
});
|
|
const highTask = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'High Priority',
|
|
priority: 'high',
|
|
order: 2,
|
|
});
|
|
const mediumTask = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'Medium Priority',
|
|
priority: 'medium',
|
|
order: 3,
|
|
});
|
|
|
|
// Create agents for all tasks
|
|
await agentRepository.create({
|
|
name: 'agent-low',
|
|
taskId: lowTask.id,
|
|
worktreeId: 'wt-low',
|
|
});
|
|
await agentRepository.create({
|
|
name: 'agent-high',
|
|
taskId: highTask.id,
|
|
worktreeId: 'wt-high',
|
|
});
|
|
await agentRepository.create({
|
|
name: 'agent-medium',
|
|
taskId: mediumTask.id,
|
|
worktreeId: 'wt-medium',
|
|
});
|
|
|
|
// Queue in wrong order (low, high, medium)
|
|
await manager.queueMerge(lowTask.id);
|
|
await manager.queueMerge(highTask.id);
|
|
await manager.queueMerge(mediumTask.id);
|
|
|
|
// Should get high priority first
|
|
const next = await manager.getNextMergeable();
|
|
expect(next).not.toBeNull();
|
|
expect(next!.taskId).toBe(highTask.id);
|
|
expect(next!.priority).toBe('high');
|
|
});
|
|
|
|
it('should order by queuedAt within same priority (oldest first)', async () => {
|
|
const task1 = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'First Task',
|
|
priority: 'medium',
|
|
order: 1,
|
|
});
|
|
const task2 = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'Second Task',
|
|
priority: 'medium',
|
|
order: 2,
|
|
});
|
|
|
|
await agentRepository.create({
|
|
name: 'agent-1',
|
|
taskId: task1.id,
|
|
worktreeId: 'wt-1',
|
|
});
|
|
await agentRepository.create({
|
|
name: 'agent-2',
|
|
taskId: task2.id,
|
|
worktreeId: 'wt-2',
|
|
});
|
|
|
|
// Queue first task, wait, then queue second
|
|
await manager.queueMerge(task1.id);
|
|
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
await manager.queueMerge(task2.id);
|
|
|
|
// Should get the first queued task
|
|
const next = await manager.getNextMergeable();
|
|
expect(next).not.toBeNull();
|
|
expect(next!.taskId).toBe(task1.id);
|
|
});
|
|
});
|
|
|
|
// ===========================================================================
|
|
// processMerges() Tests - Success Path
|
|
// ===========================================================================
|
|
|
|
describe('processMerges - success path', () => {
|
|
it('should complete clean merges and emit MergeCompletedEvent', async () => {
|
|
const task = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'Mergeable Task',
|
|
priority: 'high',
|
|
order: 1,
|
|
});
|
|
|
|
const agent = await agentRepository.create({
|
|
name: 'agent-merge',
|
|
taskId: task.id,
|
|
worktreeId: 'worktree-success',
|
|
});
|
|
|
|
await manager.queueMerge(task.id);
|
|
|
|
const results = await manager.processMerges('main');
|
|
|
|
expect(results.length).toBe(1);
|
|
expect(results[0].taskId).toBe(task.id);
|
|
expect(results[0].success).toBe(true);
|
|
|
|
// Check state updated
|
|
const state = await manager.getQueueState();
|
|
expect(state.queued.length).toBe(0);
|
|
expect(state.merged).toContain(task.id);
|
|
|
|
// Check events emitted: queued, started, completed
|
|
const eventTypes = eventBus.emittedEvents.map((e) => e.type);
|
|
expect(eventTypes).toContain('merge:queued');
|
|
expect(eventTypes).toContain('merge:started');
|
|
expect(eventTypes).toContain('merge:completed');
|
|
});
|
|
|
|
it('should process multiple tasks in priority order', async () => {
|
|
const lowTask = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'Low Priority',
|
|
priority: 'low',
|
|
order: 1,
|
|
});
|
|
const highTask = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'High Priority',
|
|
priority: 'high',
|
|
order: 2,
|
|
});
|
|
|
|
await agentRepository.create({
|
|
name: 'agent-low',
|
|
taskId: lowTask.id,
|
|
worktreeId: 'wt-low',
|
|
});
|
|
await agentRepository.create({
|
|
name: 'agent-high',
|
|
taskId: highTask.id,
|
|
worktreeId: 'wt-high',
|
|
});
|
|
|
|
await manager.queueMerge(lowTask.id);
|
|
await manager.queueMerge(highTask.id);
|
|
|
|
const results = await manager.processMerges('main');
|
|
|
|
// Should process high priority first
|
|
expect(results.length).toBe(2);
|
|
expect(results[0].taskId).toBe(highTask.id);
|
|
expect(results[1].taskId).toBe(lowTask.id);
|
|
});
|
|
});
|
|
|
|
// ===========================================================================
|
|
// processMerges() Tests - Conflict Handling
|
|
// ===========================================================================
|
|
|
|
describe('processMerges - conflict handling', () => {
|
|
it('should detect conflicts and emit MergeConflictedEvent', async () => {
|
|
const task = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'Conflicting Task',
|
|
priority: 'high',
|
|
order: 1,
|
|
});
|
|
|
|
await agentRepository.create({
|
|
name: 'agent-conflict',
|
|
taskId: task.id,
|
|
worktreeId: 'wt-conflict',
|
|
});
|
|
|
|
// Configure merge to fail with conflicts
|
|
const mergeResults = new Map<string, GitMergeResult>();
|
|
mergeResults.set('wt-conflict', {
|
|
success: false,
|
|
conflicts: ['file1.ts', 'file2.ts'],
|
|
message: 'Merge conflicts detected',
|
|
});
|
|
|
|
worktreeManager = createMockWorktreeManager(mergeResults);
|
|
manager = new DefaultCoordinationManager(
|
|
worktreeManager,
|
|
taskRepository,
|
|
agentRepository,
|
|
messageRepository,
|
|
eventBus
|
|
);
|
|
|
|
await manager.queueMerge(task.id);
|
|
const results = await manager.processMerges('main');
|
|
|
|
expect(results.length).toBe(1);
|
|
expect(results[0].taskId).toBe(task.id);
|
|
expect(results[0].success).toBe(false);
|
|
expect(results[0].conflicts).toEqual(['file1.ts', 'file2.ts']);
|
|
|
|
// Check state updated
|
|
const state = await manager.getQueueState();
|
|
expect(state.conflicted.length).toBe(1);
|
|
expect(state.conflicted[0].taskId).toBe(task.id);
|
|
expect(state.conflicted[0].conflicts).toEqual(['file1.ts', 'file2.ts']);
|
|
|
|
// Check MergeConflictedEvent emitted
|
|
const conflictEvent = eventBus.emittedEvents.find(
|
|
(e) => e.type === 'merge:conflicted'
|
|
);
|
|
expect(conflictEvent).toBeDefined();
|
|
expect((conflictEvent as any).payload.conflictingFiles).toEqual([
|
|
'file1.ts',
|
|
'file2.ts',
|
|
]);
|
|
});
|
|
|
|
it('should create resolution task on conflict', async () => {
|
|
const task = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'Original Task',
|
|
priority: 'medium',
|
|
order: 1,
|
|
});
|
|
|
|
await agentRepository.create({
|
|
name: 'agent-conflict',
|
|
taskId: task.id,
|
|
worktreeId: 'wt-conflict',
|
|
});
|
|
|
|
// Configure merge to fail
|
|
const mergeResults = new Map<string, GitMergeResult>();
|
|
mergeResults.set('wt-conflict', {
|
|
success: false,
|
|
conflicts: ['src/index.ts'],
|
|
message: 'Merge conflicts detected',
|
|
});
|
|
|
|
worktreeManager = createMockWorktreeManager(mergeResults);
|
|
manager = new DefaultCoordinationManager(
|
|
worktreeManager,
|
|
taskRepository,
|
|
agentRepository,
|
|
messageRepository,
|
|
eventBus
|
|
);
|
|
|
|
await manager.queueMerge(task.id);
|
|
await manager.processMerges('main');
|
|
|
|
// Check new task was created
|
|
const tasks = await taskRepository.findByPhaseId(testPhaseId);
|
|
const conflictTask = tasks.find((t) =>
|
|
t.name.startsWith('Resolve conflicts:')
|
|
);
|
|
|
|
expect(conflictTask).toBeDefined();
|
|
expect(conflictTask!.name).toBe('Resolve conflicts: Original Task');
|
|
expect(conflictTask!.priority).toBe('high');
|
|
expect(conflictTask!.description).toContain('src/index.ts');
|
|
|
|
// Check original task blocked
|
|
const updatedOriginal = await taskRepository.findById(task.id);
|
|
expect(updatedOriginal!.status).toBe('blocked');
|
|
|
|
// Check TaskQueuedEvent emitted for conflict task
|
|
const queuedEvent = eventBus.emittedEvents.find(
|
|
(e) =>
|
|
e.type === 'task:queued' &&
|
|
(e as any).payload.taskId === conflictTask!.id
|
|
);
|
|
expect(queuedEvent).toBeDefined();
|
|
});
|
|
|
|
it('should create message to agent on conflict', async () => {
|
|
const task = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'Task with Message',
|
|
priority: 'medium',
|
|
order: 1,
|
|
});
|
|
|
|
const agent = await agentRepository.create({
|
|
name: 'agent-msg',
|
|
taskId: task.id,
|
|
worktreeId: 'wt-msg',
|
|
});
|
|
|
|
// Configure merge to fail
|
|
const mergeResults = new Map<string, GitMergeResult>();
|
|
mergeResults.set('wt-msg', {
|
|
success: false,
|
|
conflicts: ['conflict.ts'],
|
|
message: 'Merge conflicts detected',
|
|
});
|
|
|
|
worktreeManager = createMockWorktreeManager(mergeResults);
|
|
manager = new DefaultCoordinationManager(
|
|
worktreeManager,
|
|
taskRepository,
|
|
agentRepository,
|
|
messageRepository,
|
|
eventBus
|
|
);
|
|
|
|
await manager.queueMerge(task.id);
|
|
await manager.processMerges('main');
|
|
|
|
// Check message was created
|
|
const messages = await messageRepository.findByRecipient('agent', agent.id);
|
|
expect(messages.length).toBe(1);
|
|
expect(messages[0].recipientType).toBe('agent');
|
|
expect(messages[0].recipientId).toBe(agent.id);
|
|
expect(messages[0].senderType).toBe('user');
|
|
expect(messages[0].content).toContain('Merge conflict detected');
|
|
expect(messages[0].content).toContain('conflict.ts');
|
|
});
|
|
});
|
|
|
|
// ===========================================================================
|
|
// getQueueState() Tests
|
|
// ===========================================================================
|
|
|
|
describe('getQueueState', () => {
|
|
it('should return correct counts for all states', async () => {
|
|
// Create tasks
|
|
const task1 = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'Queued Task',
|
|
priority: 'high',
|
|
order: 1,
|
|
});
|
|
const task2 = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'Conflict Task',
|
|
priority: 'medium',
|
|
order: 2,
|
|
});
|
|
|
|
await agentRepository.create({
|
|
name: 'agent-1',
|
|
taskId: task1.id,
|
|
worktreeId: 'wt-1',
|
|
});
|
|
await agentRepository.create({
|
|
name: 'agent-2',
|
|
taskId: task2.id,
|
|
worktreeId: 'wt-2',
|
|
});
|
|
|
|
// Configure task2 to conflict
|
|
const mergeResults = new Map<string, GitMergeResult>();
|
|
mergeResults.set('wt-2', {
|
|
success: false,
|
|
conflicts: ['test.ts'],
|
|
message: 'Conflict',
|
|
});
|
|
|
|
worktreeManager = createMockWorktreeManager(mergeResults);
|
|
manager = new DefaultCoordinationManager(
|
|
worktreeManager,
|
|
taskRepository,
|
|
agentRepository,
|
|
messageRepository,
|
|
eventBus
|
|
);
|
|
|
|
// Queue both, process task2 (will conflict), leave task1 queued
|
|
await manager.queueMerge(task2.id);
|
|
await manager.processMerges('main');
|
|
await manager.queueMerge(task1.id);
|
|
|
|
const state = await manager.getQueueState();
|
|
|
|
// task1 should be queued, task2 should be conflicted
|
|
expect(state.queued.length).toBe(1);
|
|
expect(state.queued[0].taskId).toBe(task1.id);
|
|
expect(state.inProgress.length).toBe(0);
|
|
expect(state.merged.length).toBe(0);
|
|
expect(state.conflicted.length).toBe(1);
|
|
expect(state.conflicted[0].taskId).toBe(task2.id);
|
|
});
|
|
});
|
|
|
|
// ===========================================================================
|
|
// handleConflict() Tests
|
|
// ===========================================================================
|
|
|
|
describe('handleConflict', () => {
|
|
it('should throw error when task not found', async () => {
|
|
await expect(
|
|
manager.handleConflict('non-existent', ['file.ts'])
|
|
).rejects.toThrow('Original task not found');
|
|
});
|
|
|
|
it('should throw error when no agent for task', async () => {
|
|
const task = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'Orphan Task',
|
|
order: 1,
|
|
});
|
|
|
|
await expect(manager.handleConflict(task.id, ['file.ts'])).rejects.toThrow(
|
|
'No agent found for task'
|
|
);
|
|
});
|
|
});
|
|
|
|
// ===========================================================================
|
|
// Error Handling Tests
|
|
// ===========================================================================
|
|
|
|
describe('error handling', () => {
|
|
it('should throw when TaskRepository not configured', async () => {
|
|
const managerNoRepo = new DefaultCoordinationManager(
|
|
worktreeManager,
|
|
undefined, // No task repo
|
|
agentRepository,
|
|
messageRepository,
|
|
eventBus
|
|
);
|
|
|
|
await expect(managerNoRepo.queueMerge('task-id')).rejects.toThrow(
|
|
'TaskRepository not configured'
|
|
);
|
|
});
|
|
|
|
it('should throw when AgentRepository not configured', async () => {
|
|
const managerNoAgentRepo = new DefaultCoordinationManager(
|
|
worktreeManager,
|
|
taskRepository,
|
|
undefined, // No agent repo
|
|
messageRepository,
|
|
eventBus
|
|
);
|
|
|
|
const task = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'Test',
|
|
order: 1,
|
|
});
|
|
|
|
await expect(managerNoAgentRepo.queueMerge(task.id)).rejects.toThrow(
|
|
'AgentRepository not configured'
|
|
);
|
|
});
|
|
|
|
it('should throw when WorktreeManager not configured', async () => {
|
|
const managerNoWorktree = new DefaultCoordinationManager(
|
|
undefined, // No worktree manager
|
|
taskRepository,
|
|
agentRepository,
|
|
messageRepository,
|
|
eventBus
|
|
);
|
|
|
|
const task = await taskRepository.create({
|
|
phaseId: testPhaseId,
|
|
name: 'Test',
|
|
order: 1,
|
|
});
|
|
|
|
await agentRepository.create({
|
|
name: 'agent-test',
|
|
taskId: task.id,
|
|
worktreeId: 'wt-test',
|
|
});
|
|
|
|
await managerNoWorktree.queueMerge(task.id);
|
|
await expect(managerNoWorktree.processMerges('main')).rejects.toThrow(
|
|
'WorktreeManager not configured'
|
|
);
|
|
});
|
|
});
|
|
});
|