qa360 2.1.2 → 2.1.4

package/core/src/hooks/__tests__/compose.test.ts

@@ -0,0 +1,636 @@
+/**
+ * ComposeHelper Tests
+ * Tests Docker Compose operations with mocked child_process
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { EventEmitter } from 'events';
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+// Mock child_process BEFORE importing ComposeHelper
+vi.mock('child_process', () => {
+  return {
+    spawn: vi.fn()
+  };
+});
+
+// Import AFTER mock
+import { ComposeHelper } from '../compose.js';
+
+describe('ComposeHelper', () => {
+  let testDir: string;
+  let helper: ComposeHelper;
+  let mockSpawn: any;
+
+  beforeEach(async () => {
+    // Create temp directory
+    testDir = join(tmpdir(), `qa360-compose-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+
+    // Create dummy compose file
+    const composeFile = join(testDir, 'services.yml');
+    writeFileSync(composeFile, `
+version: '3'
+services:
+  db:
+    image: postgres:14
+    ports:
+      - "5432:5432"
+`, 'utf-8');
+
+    // Get mock spawn
+    const { spawn } = await import('child_process');
+    mockSpawn = spawn;
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+    vi.clearAllMocks();
+  });
+
+  describe('Construction', () => {
+    it('should create helper with default compose file', () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+      expect(helper).toBeDefined();
+    });
+
+    it('should create helper with custom compose file', () => {
+      helper = new ComposeHelper({
+        workingDir: testDir,
+        composeFile: 'docker-compose.yml'
+      });
+      expect(helper).toBeDefined();
+    });
+  });
+
+  describe('up() - Start Services', () => {
+    it('should start services successfully', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock successful docker --version
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          (mockChild as any).stdout.emit('data', 'Docker version 24.0.0');
+          mockChild.emit('close', 0);
+        }, 10);
+
+        return mockChild;
+      });
+
+      // Mock successful compose up
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          (mockChild as any).stdout.emit('data', 'Container db started');
+          mockChild.emit('close', 0);
+        }, 10);
+
+        return mockChild;
+      });
+
+      await helper.up();
+      expect(mockSpawn).toHaveBeenCalledTimes(2);
+    });
+
+    it('should throw error if compose file not found', async () => {
+      helper = new ComposeHelper({
+        workingDir: testDir,
+        composeFile: 'non-existent.yml'
+      });
+
+      await expect(helper.up()).rejects.toThrow('Compose file not found');
+      await expect(helper.up()).rejects.toMatchObject({
+        code: 'QH001'
+      });
+    });
+
+    it('should throw error if Docker not available', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock failed docker --version
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          mockChild.emit('close', 1);
+        }, 10);
+
+        return mockChild;
+      });
+
+      await expect(helper.up()).rejects.toMatchObject({
+        code: 'QH005' // Docker daemon not running
+      });
+    });
+
+    it('should skip if services already up', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // First up - success
+      mockSpawn.mockImplementation(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          (mockChild as any).stdout.emit('data', 'OK');
+          mockChild.emit('close', 0);
+        }, 10);
+
+        return mockChild;
+      });
+
+      await helper.up();
+      const firstCallCount = mockSpawn.mock.calls.length;
+
+      // Second up - should skip
+      await helper.up();
+      const secondCallCount = mockSpawn.mock.calls.length;
+
+      // No additional spawn calls
+      expect(secondCallCount).toBe(firstCallCount);
+    });
+
+    it('should handle compose up failure', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock successful docker --version
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          (mockChild as any).stdout.emit('data', 'Docker version 24.0.0');
+          mockChild.emit('close', 0);
+        }, 10);
+
+        return mockChild;
+      });
+
+      // Mock failed compose up
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          (mockChild as any).stderr.emit('data', 'Network error');
+          mockChild.emit('close', 1);
+        }, 10);
+
+        return mockChild;
+      });
+
+      await expect(helper.up()).rejects.toMatchObject({
+        code: 'QH002'
+      });
+    });
+
+    it('should handle timeout', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock docker --version that never completes
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+        // Never emit close event
+        return mockChild;
+      });
+
+      await expect(helper.up(100)).rejects.toThrow();
+    }, 10000);
+  });
+
+  describe('down() - Stop Services', () => {
+    it('should stop services successfully', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock successful compose down
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          (mockChild as any).stdout.emit('data', 'Containers stopped');
+          mockChild.emit('close', 0);
+        }, 10);
+
+        return mockChild;
+      });
+
+      await helper.down();
+      expect(mockSpawn).toHaveBeenCalled();
+    });
+
+    it('should not throw on down errors', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock failed compose down
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          (mockChild as any).stderr.emit('data', 'Some error');
+          mockChild.emit('close', 1);
+        }, 10);
+
+        return mockChild;
+      });
+
+      // Should not throw
+      await expect(helper.down()).resolves.not.toThrow();
+    });
+  });
+
+  describe('getStatus() - Service Status', () => {
+    it('should get service status as JSON', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock compose ps --format json
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          (mockChild as any).stdout.emit('data', JSON.stringify({
+            Name: 'db',
+            State: 'running',
+            Ports: '5432:5432'
+          }));
+          mockChild.emit('close', 0);
+        }, 10);
+
+        return mockChild;
+      });
+
+      const status = await helper.getStatus();
+      expect(status).toHaveLength(1);
+      expect(status[0]).toMatchObject({
+        service: 'db',
+        status: 'running'
+      });
+    });
+
+    it('should handle empty status', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock empty response
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          mockChild.emit('close', 0);
+        }, 10);
+
+        return mockChild;
+      });
+
+      const status = await helper.getStatus();
+      expect(status).toEqual([]);
+    });
+
+    it('should handle invalid JSON gracefully', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock invalid JSON
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          (mockChild as any).stdout.emit('data', 'not valid json');
+          mockChild.emit('close', 0);
+        }, 10);
+
+        return mockChild;
+      });
+
+      const status = await helper.getStatus();
+      expect(status).toEqual([]);
+    });
+
+    it('should handle errors gracefully', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock error
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          mockChild.emit('close', 1);
+        }, 10);
+
+        return mockChild;
+      });
+
+      const status = await helper.getStatus();
+      expect(status).toEqual([]);
+    });
+  });
+
+  describe('Error Codes', () => {
+    it('should return QH001 for missing compose file', async () => {
+      helper = new ComposeHelper({
+        workingDir: testDir,
+        composeFile: 'missing.yml'
+      });
+
+      try {
+        await helper.up();
+        expect.fail('Should have thrown');
+      } catch (error: any) {
+        expect(error.code).toBe('QH001');
+        expect(error.suggestion).toContain('Create');
+      }
+    });
+  });
+
+  describe('down() - Additional Coverage', () => {
+    it('should successfully stop services and clean up', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock successful docker --version
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          (mockChild as any).stdout.emit('data', 'Docker version 24.0.0');
+          mockChild.emit('close', 0);
+        }, 10);
+
+        return mockChild;
+      });
+
+      // Mock successful compose up first
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          (mockChild as any).stdout.emit('data', 'Services started');
+          mockChild.emit('close', 0);
+        }, 10);
+
+        return mockChild;
+      });
+
+      await helper.up();
+
+      // Mock successful compose down
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          (mockChild as any).stdout.emit('data', 'Services stopped');
+          mockChild.emit('close', 0);
+        }, 10);
+
+        return mockChild;
+      });
+
+      await helper.down();
+
+      expect(helper.isServicesUp()).toBe(false);
+    });
+
+    it('should handle down warnings gracefully', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock compose down with non-zero exit but not critical
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          (mockChild as any).stderr.emit('data', 'Some warning');
+          mockChild.emit('close', 1);
+        }, 10);
+
+        return mockChild;
+      });
+
+      // Should not throw even with warnings
+      await expect(helper.down()).resolves.not.toThrow();
+      expect(helper.isServicesUp()).toBe(false);
+    });
+  });
+
+  describe('getStatus() - Error Handling', () => {
+    it('should handle errors gracefully and return empty array', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock error during ps command
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          mockChild.emit('error', new Error('Command failed'));
+        }, 10);
+
+        return mockChild;
+      });
+
+      const status = await helper.getStatus();
+      expect(status).toEqual([]);
+    });
+
+    it('should handle JSON parsing errors in getStatus', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock executeCompose to throw an error
+      vi.spyOn(helper as any, 'executeCompose').mockRejectedValueOnce(new Error('Failed to execute'));
+
+      const status = await helper.getStatus();
+      expect(status).toEqual([]);
+    });
+  });
+
+  describe('Public Helper Methods', () => {
+    it('should return compose file path', () => {
+      helper = new ComposeHelper({
+        workingDir: testDir,
+        composeFile: 'custom-compose.yml'
+      });
+
+      const path = helper.getComposeFilePath();
+      expect(path).toContain('custom-compose.yml');
+      expect(path).toContain(testDir);
+    });
+
+    it('should track services up/down state', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      expect(helper.isServicesUp()).toBe(false);
+
+      // Mock successful up
+      mockSpawn.mockImplementation(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          (mockChild as any).stdout.emit('data', 'OK');
+          mockChild.emit('close', 0);
+        }, 10);
+
+        return mockChild;
+      });
+
+      await helper.up();
+      expect(helper.isServicesUp()).toBe(true);
+
+      await helper.down();
+      expect(helper.isServicesUp()).toBe(false);
+    });
+  });
+
+  describe('checkDockerAvailable - Error Cases', () => {
+    it('should throw QH004 when docker command fails', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock failed docker --version
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          mockChild.emit('close', 1);
+        }, 10);
+
+        return mockChild;
+      });
+
+      try {
+        await helper.up();
+        expect.fail('Should have thrown');
+      } catch (error: any) {
+        expect(error.code).toBe('QH005'); // Daemon not running
+      }
+    });
+  });
+
+  describe('validateComposeFile()', () => {
+    it('should validate valid compose file', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock successful compose config
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          (mockChild as any).stdout.emit('data', 'Config is valid');
+          mockChild.emit('close', 0);
+        }, 10);
+
+        return mockChild;
+      });
+
+      const result = await helper.validateComposeFile();
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should detect missing compose file', async () => {
+      helper = new ComposeHelper({
+        workingDir: testDir,
+        composeFile: 'non-existent.yml'
+      });
+
+      const result = await helper.validateComposeFile();
+      expect(result.valid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0]).toContain('Compose file not found');
+    });
+
+    it('should detect invalid compose file syntax', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock failed compose config
+      mockSpawn.mockImplementationOnce(() => {
+        const mockChild = new EventEmitter();
+        (mockChild as any).stdout = new EventEmitter();
+        (mockChild as any).stderr = new EventEmitter();
+        (mockChild as any).kill = vi.fn();
+
+        setTimeout(() => {
+          (mockChild as any).stderr.emit('data', 'Invalid syntax');
+          mockChild.emit('close', 1);
+        }, 10);
+
+        return mockChild;
+      });
+
+      const result = await helper.validateComposeFile();
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it('should handle validation errors gracefully', async () => {
+      helper = new ComposeHelper({ workingDir: testDir });
+
+      // Mock executeCompose to throw an error
+      vi.spyOn(helper as any, 'executeCompose').mockRejectedValueOnce(new Error('Validation error'));
+
+      const result = await helper.validateComposeFile();
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+      expect(result.errors[0]).toContain('Could not validate compose file');
+    });
+  });
+});