claude-flow 2.0.0-alpha.61 → 2.0.0-alpha.62

package/src/cli/simple-commands/__tests__/swarm.test.js

@@ -22,7 +22,7 @@ describe('Swarm Command', () => {
   beforeEach(() => {
     consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
     consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-    
+
     mockSpinner = {
       start: jest.fn().mockReturnThis(),
       succeed: jest.fn().mockReturnThis(),
@@ -32,14 +32,14 @@ describe('Swarm Command', () => {
       text: '',
     };
     ora.mockReturnValue(mockSpinner);
-    
+
     mockSpawnProcess = {
       stdout: { on: jest.fn() },
       stderr: { on: jest.fn() },
       on: jest.fn(),
     };
     spawn.mockReturnValue(mockSpawnProcess);
-    
+
     jest.clearAllMocks();
   });
 
@@ -53,7 +53,7 @@ describe('Swarm Command', () => {
       const swarmDir = path.join(process.cwd(), '.claude', 'swarm');
       fs.ensureDir.mockResolvedValue(undefined);
       fs.writeJson.mockResolvedValue(undefined);
-      
+
       // Mock spawn process events
       mockSpawnProcess.on.mockImplementation((event, callback) => {
         if (event === 'close') {
@@ -62,30 +62,30 @@ describe('Swarm Command', () => {
       });
 
       await swarmCommand(['Build a REST API'], {});
-      
+
       expect(mockSpinner.start).toHaveBeenCalledWith('Initializing swarm...');
       expect(fs.ensureDir).toHaveBeenCalledWith(swarmDir);
-      
+
       const writeJsonCall = fs.writeJson.mock.calls[0];
       expect(writeJsonCall[0]).toBe(path.join(swarmDir, 'swarm.json'));
       expect(writeJsonCall[1]).toMatchObject({
         objective: 'Build a REST API',
         status: 'initializing',
         topology: 'hierarchical',
-        strategy: 'adaptive'
+        strategy: 'adaptive',
       });
     });
 
     test('should handle custom strategy', async () => {
       fs.ensureDir.mockResolvedValue(undefined);
       fs.writeJson.mockResolvedValue(undefined);
-      
+
       mockSpawnProcess.on.mockImplementation((event, callback) => {
         if (event === 'close') callback(0);
       });
 
       await swarmCommand(['Research task'], { strategy: 'research' });
-      
+
       const writeJsonCall = fs.writeJson.mock.calls[0];
       expect(writeJsonCall[1].strategy).toBe('research');
     });
@@ -93,13 +93,13 @@ describe('Swarm Command', () => {
     test('should handle custom topology mode', async () => {
       fs.ensureDir.mockResolvedValue(undefined);
       fs.writeJson.mockResolvedValue(undefined);
-      
+
       mockSpawnProcess.on.mockImplementation((event, callback) => {
         if (event === 'close') callback(0);
       });
 
       await swarmCommand(['Task'], { mode: 'mesh' });
-      
+
       const writeJsonCall = fs.writeJson.mock.calls[0];
       expect(writeJsonCall[1].topology).toBe('mesh');
     });
@@ -107,13 +107,13 @@ describe('Swarm Command', () => {
     test('should set max agents', async () => {
       fs.ensureDir.mockResolvedValue(undefined);
       fs.writeJson.mockResolvedValue(undefined);
-      
+
       mockSpawnProcess.on.mockImplementation((event, callback) => {
         if (event === 'close') callback(0);
       });
 
       await swarmCommand(['Task'], { 'max-agents': '10' });
-      
+
       const writeJsonCall = fs.writeJson.mock.calls[0];
       expect(writeJsonCall[1].maxAgents).toBe(10);
     });
@@ -121,13 +121,13 @@ describe('Swarm Command', () => {
     test('should enable parallel execution', async () => {
       fs.ensureDir.mockResolvedValue(undefined);
       fs.writeJson.mockResolvedValue(undefined);
-      
+
       mockSpawnProcess.on.mockImplementation((event, callback) => {
         if (event === 'close') callback(0);
       });
 
       await swarmCommand(['Task'], { parallel: true });
-      
+
       const writeJsonCall = fs.writeJson.mock.calls[0];
       expect(writeJsonCall[1].parallel).toBe(true);
     });
@@ -135,17 +135,17 @@ describe('Swarm Command', () => {
     test('should enable monitoring', async () => {
       fs.ensureDir.mockResolvedValue(undefined);
       fs.writeJson.mockResolvedValue(undefined);
-      
+
       mockSpawnProcess.on.mockImplementation((event, callback) => {
         if (event === 'close') callback(0);
       });
 
       await swarmCommand(['Task'], { monitor: true });
-      
+
       expect(spawn).toHaveBeenCalledWith(
         'npx',
         expect.arrayContaining(['--monitor']),
-        expect.any(Object)
+        expect.any(Object),
       );
     });
   });
@@ -159,21 +159,21 @@ describe('Swarm Command', () => {
         topology: 'hierarchical',
         agents: [
           { id: 'agent-1', type: 'researcher', status: 'active' },
-          { id: 'agent-2', type: 'coder', status: 'working' }
+          { id: 'agent-2', type: 'coder', status: 'working' },
         ],
         metrics: {
           startTime: new Date(Date.now() - 300000).toISOString(),
           tasksCompleted: 15,
           tasksInProgress: 3,
-          tasksPending: 7
-        }
+          tasksPending: 7,
+        },
       };
 
       fs.pathExists.mockResolvedValue(true);
       fs.readJson.mockResolvedValue(mockSwarmData);
 
       await swarmCommand(['status'], {});
-      
+
       const output = consoleLogSpy.mock.calls.flat().join('\n');
       expect(output).toContain('Swarm Status');
       expect(output).toContain('Build API');
@@ -187,10 +187,8 @@ describe('Swarm Command', () => {
       fs.pathExists.mockResolvedValue(false);
 
       await swarmCommand(['status'], {});
-      
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining('No active swarm found')
-      );
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('No active swarm found'));
     });
   });
 
@@ -199,7 +197,7 @@ describe('Swarm Command', () => {
       const mockSwarmData = {
         id: 'swarm-123',
         status: 'active',
-        agents: [{ id: 'agent-1' }, { id: 'agent-2' }]
+        agents: [{ id: 'agent-1' }, { id: 'agent-2' }],
       };
 
       fs.pathExists.mockResolvedValue(true);
@@ -208,10 +206,10 @@ describe('Swarm Command', () => {
       fs.remove.mockResolvedValue(undefined);
 
       await swarmCommand(['stop'], {});
-      
+
       expect(mockSpinner.succeed).toHaveBeenCalledWith('Swarm stopped successfully');
       expect(fs.remove).toHaveBeenCalledWith(
-        path.join(process.cwd(), '.claude', 'swarm', 'swarm.json')
+        path.join(process.cwd(), '.claude', 'swarm', 'swarm.json'),
       );
     });
 
@@ -220,7 +218,7 @@ describe('Swarm Command', () => {
       fs.remove.mockResolvedValue(undefined);
 
       await swarmCommand(['stop'], { force: true });
-      
+
       expect(fs.remove).toHaveBeenCalled();
       expect(mockSpinner.warn).toHaveBeenCalledWith('Swarm forcefully terminated');
     });
@@ -230,7 +228,7 @@ describe('Swarm Command', () => {
     test('should pause active swarm', async () => {
       const mockSwarmData = {
         id: 'swarm-123',
-        status: 'active'
+        status: 'active',
       };
 
       fs.pathExists.mockResolvedValue(true);
@@ -238,7 +236,7 @@ describe('Swarm Command', () => {
       fs.writeJson.mockResolvedValue(undefined);
 
       await swarmCommand(['pause'], {});
-      
+
       const writeCall = fs.writeJson.mock.calls[0];
       expect(writeCall[1].status).toBe('paused');
       expect(mockSpinner.succeed).toHaveBeenCalledWith('Swarm paused');
@@ -247,7 +245,7 @@ describe('Swarm Command', () => {
     test('should resume paused swarm', async () => {
       const mockSwarmData = {
         id: 'swarm-123',
-        status: 'paused'
+        status: 'paused',
       };
 
       fs.pathExists.mockResolvedValue(true);
@@ -255,7 +253,7 @@ describe('Swarm Command', () => {
       fs.writeJson.mockResolvedValue(undefined);
 
       await swarmCommand(['resume'], {});
-      
+
       const writeCall = fs.writeJson.mock.calls[0];
       expect(writeCall[1].status).toBe('active');
       expect(mockSpinner.succeed).toHaveBeenCalledWith('Swarm resumed');
@@ -267,14 +265,14 @@ describe('Swarm Command', () => {
       const mockLogs = [
         { timestamp: new Date().toISOString(), level: 'info', message: 'Swarm initialized' },
         { timestamp: new Date().toISOString(), level: 'info', message: 'Agent spawned' },
-        { timestamp: new Date().toISOString(), level: 'error', message: 'Task failed' }
+        { timestamp: new Date().toISOString(), level: 'error', message: 'Task failed' },
       ];
 
       fs.pathExists.mockResolvedValue(true);
       fs.readJson.mockResolvedValue({ logs: mockLogs });
 
       await swarmCommand(['logs'], {});
-      
+
       const output = consoleLogSpy.mock.calls.flat().join('\n');
       expect(output).toContain('Swarm Logs');
       expect(output).toContain('Swarm initialized');
@@ -286,14 +284,14 @@ describe('Swarm Command', () => {
       const mockLogs = [
         { timestamp: new Date().toISOString(), level: 'info', message: 'Info message' },
         { timestamp: new Date().toISOString(), level: 'error', message: 'Error message' },
-        { timestamp: new Date().toISOString(), level: 'debug', message: 'Debug message' }
+        { timestamp: new Date().toISOString(), level: 'debug', message: 'Debug message' },
       ];
 
       fs.pathExists.mockResolvedValue(true);
       fs.readJson.mockResolvedValue({ logs: mockLogs });
 
       await swarmCommand(['logs'], { level: 'error' });
-      
+
       const output = consoleLogSpy.mock.calls.flat().join('\n');
       expect(output).toContain('Error message');
       expect(output).not.toContain('Info message');
@@ -304,14 +302,14 @@ describe('Swarm Command', () => {
       const mockLogs = Array.from({ length: 50 }, (_, i) => ({
         timestamp: new Date().toISOString(),
         level: 'info',
-        message: `Log entry ${i + 1}`
+        message: `Log entry ${i + 1}`,
       }));
 
       fs.pathExists.mockResolvedValue(true);
       fs.readJson.mockResolvedValue({ logs: mockLogs });
 
       await swarmCommand(['logs'], { tail: '10' });
-      
+
       const output = consoleLogSpy.mock.calls.flat().join('\n');
       expect(output).toContain('Log entry 50');
       expect(output).toContain('Log entry 41');
@@ -322,9 +320,9 @@ describe('Swarm Command', () => {
   describe('error handling', () => {
     test('should handle missing objective', async () => {
       await swarmCommand([], {});
-      
+
       expect(consoleErrorSpy).toHaveBeenCalledWith(
-        expect.stringContaining('objective is required')
+        expect.stringContaining('objective is required'),
       );
     });
 
@@ -333,24 +331,22 @@ describe('Swarm Command', () => {
       fs.writeJson.mockResolvedValue(undefined);
 
       await swarmCommand(['Task'], { strategy: 'invalid-strategy' });
-      
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Invalid strategy')
-      );
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid strategy'));
     });
 
     test('should handle spawn process errors', async () => {
       fs.ensureDir.mockResolvedValue(undefined);
       fs.writeJson.mockResolvedValue(undefined);
-      
+
       mockSpawnProcess.on.mockImplementation((event, callback) => {
         if (event === 'error') callback(new Error('Spawn failed'));
       });
 
       await swarmCommand(['Task'], {});
-      
+
       expect(mockSpinner.fail).toHaveBeenCalledWith(
-        expect.stringContaining('Failed to initialize swarm')
+        expect.stringContaining('Failed to initialize swarm'),
       );
     });
 
@@ -358,20 +354,18 @@ describe('Swarm Command', () => {
       fs.ensureDir.mockRejectedValue(new Error('Permission denied'));
 
       await swarmCommand(['Task'], {});
-      
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Error:')
-      );
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Error:'));
     });
   });
 
   describe('help', () => {
     test('should show help for invalid subcommand', async () => {
       await swarmCommand(['invalid'], {});
-      
+
       const output = consoleLogSpy.mock.calls.flat().join('\n');
       expect(output).toContain('Swarm Orchestration');
       expect(output).toContain('USAGE:');
     });
   });
-});
+});