awc-zns-mtd 2.9.0 → 2.10.3

package/test/integration/cli/cli-commands.integration.test.js

@@ -0,0 +1,105 @@
+/**
+ * Tests de integración para CLI
+ * Pruebas end-to-end de comandos principales
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+
+// Leer versión actual del package.json para tests dinámicos
+const packageJson = require('../../../package.json');
+const currentVersion = packageJson.version;
+
+describe('CLI Integration Tests', () => {
+  let testDir;
+  const cliPath = path.join(__dirname, '../../../tools/cli/awc-cli.js');
+
+  beforeEach(async () => {
+    // Crear directorio temporal para tests
+    testDir = path.join(os.tmpdir(), `awc-test-${Date.now()}`);
+    await fs.ensureDir(testDir);
+  });
+
+  afterEach(async () => {
+    // Limpiar directorio temporal
+    await fs.remove(testDir);
+  });
+
+  describe('Comando: version', () => {
+    test('debe mostrar la versión del método', () => {
+      const output = execSync(`node "${cliPath}" version`, {
+        encoding: 'utf-8',
+        cwd: testDir
+      });
+
+      expect(output).toContain(currentVersion);
+      expect(output).toContain('ZΞNAPSΞS');
+    });
+
+    test('debe ejecutarse sin errores', () => {
+      expect(() => {
+        execSync(`node "${cliPath}" version`, {
+          cwd: testDir,
+          stdio: 'ignore'
+        });
+      }).not.toThrow();
+    });
+  });
+
+  describe('Comando: --help', () => {
+    test('debe mostrar ayuda general', () => {
+      const output = execSync(`node "${cliPath}" --help`, {
+        encoding: 'utf-8',
+        cwd: testDir
+      });
+
+      expect(output).toContain('install');
+      expect(output).toContain('version');
+    });
+  });
+
+  describe('Comando: --version', () => {
+    test('debe mostrar versión corta', () => {
+      const output = execSync(`node "${cliPath}" --version`, {
+        encoding: 'utf-8',
+        cwd: testDir
+      });
+
+      expect(output).toContain(currentVersion);
+    });
+  });
+
+  describe('Validación de comandos', () => {
+    test('comando inválido debe fallar', () => {
+      expect(() => {
+        execSync(`node "${cliPath}" comando-inexistente`, {
+          cwd: testDir,
+          stdio: 'pipe'
+        });
+      }).toThrow();
+    });
+  });
+
+  describe('Logs generados', () => {
+    test('debe crear directorio de logs', async () => {
+      // Ejecutar un comando para generar logs
+      try {
+        execSync(`node "${cliPath}" version`, {
+          cwd: testDir,
+          stdio: 'ignore'
+        });
+      } catch {
+        // Ignorar errores de ejecución
+      }
+
+      // Verificar que se crearon logs (si el comando los genera)
+      const logsDir = path.join(process.cwd(), '.awc', 'logs');
+      const logsExist = await fs.pathExists(logsDir);
+
+      // Los logs pueden o no existir dependiendo de la implementación
+      expect(typeof logsExist).toBe('boolean');
+    });
+  });
+});

package/test/setup.js

@@ -0,0 +1,22 @@
+/**
+ * Jest Setup
+ * Configuración global para tests
+ */
+
+// Suprimir console.log en tests (opcional)
+global.console = {
+  ...console,
+  log: jest.fn(),
+  debug: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn()
+};
+
+// Configurar timeout global
+jest.setTimeout(10000);
+
+// Limpiar mocks después de cada test
+afterEach(() => {
+  jest.clearAllMocks();
+});

package/test/unit/commands/version.test.js

@@ -0,0 +1,39 @@
+/**
+ * Tests unitarios para el comando 'version'
+ */
+
+const { versionCommand } = require('../../../tools/cli/commands/version');
+const { getVersion } = require('../../../tools/cli/utils/version');
+
+// Mock de dependencias
+jest.mock('../../../tools/cli/utils/version');
+jest.mock('../../../tools/cli/utils/console-logger', () => ({
+  displayLogo: jest.fn()
+}));
+
+describe('Command: version', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('debe mostrar la versión actual del método', async () => {
+    // Arrange
+    getVersion.mockReturnValue('2.9.0');
+
+    // Act
+    await versionCommand();
+
+    // Assert
+    expect(getVersion).toHaveBeenCalled();
+  });
+
+  test('debe manejar errores al obtener la versión', async () => {
+    // Arrange
+    getVersion.mockImplementation(() => {
+      throw new Error('No se pudo leer package.json');
+    });
+
+    // Act & Assert
+    await expect(versionCommand()).rejects.toThrow();
+  });
+});

package/test/unit/config/config-manager.test.js

@@ -0,0 +1,147 @@
+/**
+ * Tests unitarios para ConfigManager
+ */
+
+const ConfigManager = require('../../../tools/config/config-manager');
+
+describe('ConfigManager', () => {
+  describe('Constantes de directorio', () => {
+    test('debe retornar directorios correctos', () => {
+      expect(ConfigManager.AWC_DIR).toBe('.awc');
+      expect(ConfigManager.AGENTS_DIR).toContain('agents');
+      expect(ConfigManager.WORKFLOWS_DIR).toContain('workflows');
+      expect(ConfigManager.TEMPLATES_DIR).toContain('templates');
+    });
+  });
+
+  describe('Agentes Core', () => {
+    test('debe tener 4 agentes core', () => {
+      expect(ConfigManager.CORE_AGENTS).toHaveLength(4);
+      expect(ConfigManager.CORE_AGENTS).toContain('zen-master');
+      expect(ConfigManager.CORE_AGENTS).toContain('architect-senior');
+    });
+  });
+
+  describe('Tipos de proyecto', () => {
+    test('debe incluir todos los tipos soportados', () => {
+      expect(ConfigManager.PROJECT_TYPES).toContain('greenfield');
+      expect(ConfigManager.PROJECT_TYPES).toContain('migration');
+      expect(ConfigManager.PROJECT_TYPES).toContain('code-audit');
+      expect(ConfigManager.PROJECT_TYPES).toContain('enterprise');
+    });
+  });
+
+  describe('Tecnologías soportadas', () => {
+    test('debe incluir tecnologías principales', () => {
+      const techs = ConfigManager.SUPPORTED_TECHNOLOGIES;
+      expect(techs).toContain('java');
+      expect(techs).toContain('dotnet');
+      expect(techs).toContain('python');
+      expect(techs).toContain('react');
+      expect(techs).toContain('nodejs');
+    });
+  });
+
+  describe('getProjectPath', () => {
+    test('debe construir path correcto', () => {
+      const cwd = '/home/user/project';
+      const path = ConfigManager.getProjectPath(cwd, 'agents');
+
+      expect(path).toContain('.awc');
+      expect(path).toContain('agents');
+    });
+
+    test('debe manejar path vacío', () => {
+      const cwd = '/home/user/project';
+      const path = ConfigManager.getProjectPath(cwd);
+
+      expect(path).toContain('.awc');
+      expect(path).not.toContain('undefined');
+    });
+  });
+
+  describe('getAgentsPath', () => {
+    test('debe retornar path a agentes', () => {
+      const cwd = '/project';
+      const path = ConfigManager.getAgentsPath(cwd);
+
+      expect(path).toContain('.awc');
+      expect(path).toContain('agents');
+    });
+  });
+
+  describe('validateConfig', () => {
+    test('debe validar configuración correcta', () => {
+      const config = {
+        projectName: 'test-project',
+        version: '1.0.0',
+        workflow: 'standard'
+      };
+
+      const result = ConfigManager.validateConfig(config);
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    test('debe rechazar config sin projectName', () => {
+      const config = {
+        version: '1.0.0'
+      };
+
+      const result = ConfigManager.validateConfig(config);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('projectName es requerido');
+    });
+
+    test('debe rechazar config sin version', () => {
+      const config = {
+        projectName: 'test'
+      };
+
+      const result = ConfigManager.validateConfig(config);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('version es requerida');
+    });
+
+    test('debe rechazar workflow inválido', () => {
+      const config = {
+        projectName: 'test',
+        version: '1.0.0',
+        workflow: 'invalid-workflow'
+      };
+
+      const result = ConfigManager.validateConfig(config);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Configuración de entorno', () => {
+    test('debe obtener info del entorno', () => {
+      const env = ConfigManager.getEnvironmentConfig();
+
+      expect(env).toHaveProperty('nodeVersion');
+      expect(env).toHaveProperty('platform');
+      expect(env).toHaveProperty('arch');
+      expect(env).toHaveProperty('cwd');
+      expect(env).toHaveProperty('env');
+    });
+  });
+
+  describe('Límites y validaciones', () => {
+    test('debe tener límites definidos', () => {
+      expect(ConfigManager.MAX_PROJECT_NAME_LENGTH).toBe(50);
+      expect(ConfigManager.MIN_PROJECT_NAME_LENGTH).toBe(3);
+    });
+
+    test('debe tener nombres reservados', () => {
+      expect(ConfigManager.RESERVED_NAMES).toContain('node_modules');
+      expect(ConfigManager.RESERVED_NAMES).toContain('.git');
+      expect(ConfigManager.RESERVED_NAMES).toContain('package.json');
+    });
+  });
+});

package/test/unit/utils/file-utils.test.js

@@ -0,0 +1,177 @@
+/**
+ * Tests unitarios para file-utils
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+const {
+  loadConfig,
+  updateConfig,
+  createConfigFile,
+  readYamlFile,
+  writeYamlFile,
+  isDirectoryEmpty
+} = require('../../../tools/cli/utils/file-utils');
+
+// Mock de fs-extra
+jest.mock('fs-extra');
+
+describe('File Utils', () => {
+  const testDir = '/test/project/.awc';
+  const configJsonPath = path.join(testDir, 'config.json');
+  const configYamlPath = path.join(testDir, 'config.yaml');
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('loadConfig', () => {
+    test('debe cargar configuración JSON cuando existe', async () => {
+      const mockConfig = {
+        projectName: 'test-project',
+        version: '1.0.0',
+        initialized: true
+      };
+
+      fs.pathExists.mockImplementation((filePath) => {
+        return Promise.resolve(filePath === configJsonPath);
+      });
+      fs.readJson.mockResolvedValue(mockConfig);
+
+      const config = await loadConfig(testDir);
+
+      expect(fs.pathExists).toHaveBeenCalledWith(configJsonPath);
+      expect(fs.readJson).toHaveBeenCalledWith(configJsonPath);
+      expect(config).toHaveProperty('projectName', 'test-project');
+    });
+
+    test('debe cargar configuración YAML cuando JSON no existe', async () => {
+      const mockConfig = {
+        projectName: 'test-project',
+        version: '1.0.0'
+      };
+
+      fs.pathExists.mockImplementation((filePath) => {
+        if (filePath === configJsonPath) {
+          return Promise.resolve(false);
+        }
+        if (filePath === configYamlPath) {
+          return Promise.resolve(true);
+        }
+        return Promise.resolve(false);
+      });
+      fs.readFile.mockResolvedValue(yaml.dump(mockConfig));
+
+      const config = await loadConfig(testDir);
+
+      expect(fs.pathExists).toHaveBeenCalledWith(configJsonPath);
+      expect(fs.pathExists).toHaveBeenCalledWith(configYamlPath);
+      expect(config).toHaveProperty('projectName', 'test-project');
+    });
+
+    test('debe retornar null si no existe archivo', async () => {
+      fs.pathExists.mockResolvedValue(false);
+
+      const config = await loadConfig(testDir);
+
+      expect(config).toBeNull();
+    });
+  });
+
+  describe('updateConfig', () => {
+    test('debe actualizar configuración existente en JSON', async () => {
+      const newConfig = {
+        projectName: 'updated-project',
+        version: '2.0.0'
+      };
+
+      fs.writeJson.mockResolvedValue();
+
+      await updateConfig(testDir, newConfig);
+
+      expect(fs.writeJson).toHaveBeenCalledWith(configJsonPath, newConfig, { spaces: 2 });
+    });
+  });
+
+  describe('createConfigFile', () => {
+    test('debe crear archivo YAML correctamente', async () => {
+      const config = {
+        projectName: 'new-project',
+        version: '1.0.0'
+      };
+
+      fs.writeFile.mockResolvedValue();
+
+      await createConfigFile(testDir, config);
+
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        configYamlPath,
+        expect.stringContaining('projectName:'),
+        'utf8'
+      );
+    });
+  });
+
+  describe('readYamlFile', () => {
+    test('debe leer archivo YAML correctamente', async () => {
+      const mockData = { key: 'value', nested: { prop: 123 } };
+      fs.readFile.mockResolvedValue(yaml.dump(mockData));
+
+      const result = await readYamlFile('/test/file.yaml');
+
+      expect(result).toEqual(mockData);
+    });
+
+    test('debe retornar null en caso de error', async () => {
+      fs.readFile.mockRejectedValue(new Error('File not found'));
+
+      const result = await readYamlFile('/test/missing.yaml');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('writeYamlFile', () => {
+    test('debe escribir archivo YAML correctamente', async () => {
+      const data = { name: 'test', value: 42 };
+      fs.writeFile.mockResolvedValue();
+
+      await writeYamlFile('/test/output.yaml', data);
+
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        '/test/output.yaml',
+        expect.stringContaining('name: test'),
+        'utf8'
+      );
+    });
+  });
+
+  describe('isDirectoryEmpty', () => {
+    test('debe retornar true si directorio está vacío', async () => {
+      fs.pathExists.mockResolvedValue(true);
+      fs.readdir.mockResolvedValue([]);
+
+      const result = await isDirectoryEmpty(testDir);
+
+      expect(result).toBe(true);
+    });
+
+    test('debe retornar false si directorio tiene archivos', async () => {
+      fs.pathExists.mockResolvedValue(true);
+      fs.readdir.mockResolvedValue(['file1.txt', 'file2.txt']);
+
+      const result = await isDirectoryEmpty(testDir);
+
+      expect(result).toBe(false);
+    });
+
+    test('debe retornar true si directorio no existe', async () => {
+      fs.pathExists.mockResolvedValue(false);
+
+      const result = await isDirectoryEmpty('/nonexistent');
+
+      expect(result).toBe(true);
+    });
+  });
+});

package/test/unit/utils/validators.test.js

@@ -0,0 +1,57 @@
+/**
+ * Tests unitarios para utilidades de validación
+ */
+
+const {
+  validateProjectName,
+  validatePath,
+  sanitizePath
+} = require('../../../tools/cli/utils/validators');
+
+describe('Validators Utils', () => {
+  describe('validateProjectName', () => {
+    test('debe aceptar nombres válidos', () => {
+      expect(validateProjectName('mi-proyecto')).toBe(true);
+      expect(validateProjectName('proyecto_123')).toBe(true);
+      expect(validateProjectName('MiProyecto')).toBe(true);
+    });
+
+    test('debe rechazar nombres inválidos', () => {
+      expect(validateProjectName('')).toBe(false);
+      expect(validateProjectName('   ')).toBe(false);
+      expect(validateProjectName('proyecto con espacios')).toBe(false);
+      expect(validateProjectName('proyecto@especial')).toBe(false);
+      expect(validateProjectName('../malicious')).toBe(false);
+    });
+
+    test('debe rechazar nombres reservados', () => {
+      expect(validateProjectName('node_modules')).toBe(false);
+      expect(validateProjectName('package.json')).toBe(false);
+    });
+  });
+
+  describe('validatePath', () => {
+    test('debe validar paths seguros', () => {
+      expect(validatePath('./relative/path')).toBe(true);
+      expect(validatePath('C:\\Users\\project')).toBe(true);
+    });
+
+    test('debe rechazar paths maliciosos', () => {
+      expect(validatePath('../../../etc/passwd')).toBe(false);
+      expect(validatePath('C:\\Windows\\System32')).toBe(false);
+    });
+  });
+
+  describe('sanitizePath', () => {
+    test('debe normalizar paths', () => {
+      const result = sanitizePath('path//to///file');
+      expect(result).not.toContain('//');
+      expect(sanitizePath('path\\to\\file')).not.toContain('\\\\');
+    });
+
+    test('debe eliminar caracteres peligrosos', () => {
+      expect(sanitizePath('path/../other')).not.toContain('..');
+      expect(sanitizePath('path/./file')).not.toContain('./');
+    });
+  });
+});