stigmergy 1.2.0 → 1.2.6

package/test/encryption-simple-test.js

@@ -1,110 +0,0 @@
-/**
- * Simple test script for encryption functions
- */
-
-const { encryptData, decryptData, generateKey } = require('../src/utils');
-
-console.log('Testing encryption functions...');
-console.log('================================');
-
-// Test 1: Generate key
-console.log('Test 1: Key generation');
-let secretKey;
-try {
-  secretKey = generateKey();
-  console.log('✓ Generated 32-byte key');
-  console.log('✓ Key type:', typeof secretKey);
-} catch (error) {
-  console.error('✗ Key generation failed:', error.message);
-  process.exit(1);
-}
-
-// Test 2: Encrypt string data
-console.log('\nTest 2: String encryption');
-let encryptedObj;
-try {
-  const plaintext = 'Hello, World!';
-  encryptedObj = encryptData(plaintext, secretKey);
-  console.log('✓ String encryption successful');
-  console.log('✓ Encrypted object has required properties');
-} catch (error) {
-  console.error('✗ String encryption failed:', error.message);
-  process.exit(1);
-}
-
-// Test 3: Decrypt data
-console.log('\nTest 3: Data decryption');
-try {
-  const decrypted = decryptData(encryptedObj, secretKey);
-  console.log('✓ Data decryption successful');
-  console.log('✓ Decrypted data matches original');
-} catch (error) {
-  console.error('✗ Data decryption failed:', error.message);
-  process.exit(1);
-}
-
-// Test 4: Data integrity
-console.log('\nTest 4: Data integrity');
-try {
-  const originalData = 'Confidential information';
-  const encrypted = encryptData(originalData, secretKey);
-  const decrypted = decryptData(encrypted, secretKey);
-  
-  if (originalData === decrypted) {
-    console.log('✓ Data integrity maintained');
-  } else {
-    console.error('✗ Data integrity check failed');
-    process.exit(1);
-  }
-} catch (error) {
-  console.error('✗ Data integrity test failed:', error.message);
-  process.exit(1);
-}
-
-// Test 5: Unicode support
-console.log('\nTest 5: Unicode support');
-try {
-  const unicodeData = 'Hello, 世界! 🌍 Welcome to 数据加密!';
-  const encrypted = encryptData(unicodeData, secretKey);
-  const decrypted = decryptData(encrypted, secretKey);
-  
-  if (unicodeData === decrypted) {
-    console.log('✓ Unicode data handled correctly');
-  } else {
-    console.error('✗ Unicode test failed');
-    process.exit(1);
-  }
-} catch (error) {
-  console.error('✗ Unicode test failed:', error.message);
-  process.exit(1);
-}
-
-// Test 6: Error handling
-console.log('\nTest 6: Error handling');
-try {
-  encryptData('', secretKey);
-  console.error('✗ Empty data validation failed');
-  process.exit(1);
-} catch (error) {
-  if (error.message === 'Data to encrypt cannot be empty') {
-    console.log('✓ Empty data validation works');
-  } else {
-    console.error('✗ Unexpected error for empty data:', error.message);
-    process.exit(1);
-  }
-}
-
-try {
-  encryptData('test data', null);
-  console.error('✗ Missing key validation failed');
-  process.exit(1);
-} catch (error) {
-  if (error.message === 'Secret key is required') {
-    console.log('✓ Missing key validation works');
-  } else {
-    console.error('✗ Unexpected error for missing key:', error.message);
-    process.exit(1);
-  }
-}
-
-console.log('\nAll tests passed! 🎉');

package/test/encryption.test.js

@@ -1,129 +0,0 @@
-/**
- * Test suite for encryption functions
- */
-
-const { encryptData, decryptData, generateKey } = require('../src/utils');
-
-describe('Encryption Functions', () => {
-  let secretKey;
-  
-  beforeEach(() => {
-    // Generate a new key for each test
-    secretKey = generateKey();
-  });
-  
-  describe('generateKey()', () => {
-    test('should generate a 32-byte key by default', () => {
-      const key = generateKey();
-      expect(key).toBeInstanceOf(Buffer);
-      expect(key.length).toBe(32);
-    });
-    
-    test('should generate a key of specified length', () => {
-      const key = generateKey(16);
-      expect(key).toBeInstanceOf(Buffer);
-      expect(key.length).toBe(16);
-    });
-  });
-  
-  describe('encryptData()', () => {
-    test('should encrypt string data', () => {
-      const plaintext = 'Hello, World!';
-      const encryptedObj = encryptData(plaintext, secretKey);
-      
-      expect(encryptedObj).toHaveProperty('encryptedData');
-      expect(encryptedObj).toHaveProperty('iv');
-      expect(encryptedObj).toHaveProperty('authTag');
-      expect(typeof encryptedObj.encryptedData).toBe('string');
-      expect(typeof encryptedObj.iv).toBe('string');
-      expect(typeof encryptedObj.authTag).toBe('string');
-    });
-    
-    test('should encrypt buffer data', () => {
-      const plaintext = Buffer.from('Hello, World!', 'utf8');
-      const encryptedObj = encryptData(plaintext, secretKey);
-      
-      expect(encryptedObj).toHaveProperty('encryptedData');
-      expect(encryptedObj).toHaveProperty('iv');
-      expect(encryptedObj).toHaveProperty('authTag');
-    });
-    
-    test('should throw error for empty data', () => {
-      expect(() => encryptData('', secretKey)).toThrow('Data to encrypt cannot be empty');
-      expect(() => encryptData(null, secretKey)).toThrow('Data to encrypt cannot be empty');
-      expect(() => encryptData(undefined, secretKey)).toThrow('Data to encrypt cannot be empty');
-    });
-    
-    test('should throw error for missing secret key', () => {
-      expect(() => encryptData('test data', null)).toThrow('Secret key is required');
-      expect(() => encryptData('test data', undefined)).toThrow('Secret key is required');
-    });
-  });
-  
-  describe('decryptData()', () => {
-    test('should decrypt encrypted data correctly', () => {
-      const plaintext = 'Secret message for testing';
-      const encryptedObj = encryptData(plaintext, secretKey);
-      const decrypted = decryptData(encryptedObj, secretKey);
-      
-      expect(decrypted).toBe(plaintext);
-    });
-    
-    test('should decrypt buffer data correctly', () => {
-      const plaintext = Buffer.from('Secret message for testing', 'utf8');
-      const encryptedObj = encryptData(plaintext, secretKey);
-      const decrypted = decryptData(encryptedObj, secretKey);
-      
-      expect(decrypted).toBe('Secret message for testing');
-    });
-    
-    test('should throw error for invalid encrypted object', () => {
-      expect(() => decryptData({}, secretKey)).toThrow('Invalid encrypted object');
-      expect(() => decryptData({ encryptedData: 'test' }, secretKey)).toThrow('Invalid encrypted object');
-      expect(() => decryptData(null, secretKey)).toThrow('Invalid encrypted object');
-      expect(() => decryptData(undefined, secretKey)).toThrow('Invalid encrypted object');
-    });
-    
-    test('should throw error for missing secret key', () => {
-      const encryptedObj = encryptData('test data', secretKey);
-      expect(() => decryptData(encryptedObj, null)).toThrow('Secret key is required');
-      expect(() => decryptData(encryptedObj, undefined)).toThrow('Secret key is required');
-    });
-    
-    test('should throw error for tampered data', () => {
-      const plaintext = 'Original message';
-      const encryptedObj = encryptData(plaintext, secretKey);
-      
-      // Tamper with the encrypted data
-      encryptedObj.encryptedData = 'tampered' + encryptedObj.encryptedData;
-      
-      expect(() => decryptData(encryptedObj, secretKey)).toThrow();
-    });
-  });
-  
-  describe('encrypt/decrypt integration', () => {
-    test('should maintain data integrity through encrypt/decrypt cycle', () => {
-      const originalData = 'This is a test of the encryption system.';
-      const encryptedObj = encryptData(originalData, secretKey);
-      const decryptedData = decryptData(encryptedObj, secretKey);
-      
-      expect(decryptedData).toBe(originalData);
-    });
-    
-    test('should work with unicode characters', () => {
-      const originalData = 'Hello, 世界! 🌍 💻';
-      const encryptedObj = encryptData(originalData, secretKey);
-      const decryptedData = decryptData(encryptedObj, secretKey);
-      
-      expect(decryptedData).toBe(originalData);
-    });
-    
-    test('should work with empty strings', () => {
-      const originalData = '';
-      const encryptedObj = encryptData(originalData, secretKey);
-      const decryptedData = decryptData(encryptedObj, secretKey);
-      
-      expect(decryptedData).toBe(originalData);
-    });
-  });
-});

package/test/enhanced-main-alignment.test.js

@@ -1,298 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Enhanced Main.js 功能对齐测试 - TDD驱动开发
- * 基于main.js完整功能，测试enhanced版本的对齐情况
- */
-
-const { strict: assert } = require('assert');
-const { spawn } = require('child_process');
-const fs = require('fs').promises;
-const path = require('path');
-
-class EnhancedMainAlignTest {
-    constructor() {
-        this.testResults = [];
-        this.mainJsPath = path.join(process.cwd(), 'package', 'src', 'main.js');
-        this.enhancedJsPath = path.join(process.cwd(), 'package', 'src', 'enhanced-main.js');
-    }
-
-    // TDD测试：命令行参数支持
-    async testCommandLineArguments() {
-        console.log('🧪 测试命令行参数支持...');
-
-        const requiredCommands = [
-            'init', 'status', 'scan', 'deploy',
-            'validate', 'check-project', 'clean', 'install'
-        ];
-
-        for (const cmd of requiredCommands) {
-            try {
-                const result = await this.runCommand(this.enhancedJsPath, [cmd, '--help'], { timeout: 5000 });
-                this.addTest(`命令支持: ${cmd}`, result.exitCode === 0);
-            } catch (error) {
-                this.addTest(`命令支持: ${cmd}`, false, error.message);
-            }
-        }
-    }
-
-    // TDD测试：项目初始化功能
-    async testProjectInitialization() {
-        console.log('🧪 测试项目初始化功能...');
-
-        const testProjectDir = path.join(process.cwd(), 'test-project-temp');
-
-        try {
-            // 创建测试目录
-            await fs.mkdir(testProjectDir, { recursive: true });
-
-            // 测试初始化
-            const result = await this.runCommand(this.enhancedJsPath, ['init', testProjectDir]);
-
-            // 验证配置文件生成
-            const configPath = path.join(testProjectDir, '.stigmergy-project', 'stigmergy-config.json');
-            const configExists = await this.fileExists(configPath);
-
-            // 验证配置内容
-            let configValid = false;
-            if (configExists) {
-                const config = JSON.parse(await fs.readFile(configPath, 'utf8'));
-                configValid = config.projectType && config.adapters && Array.isArray(config.adapters);
-            }
-
-            this.addTest('项目初始化：生成配置文件', configExists);
-            this.addTest('项目初始化：配置内容有效', configValid);
-            this.addTest('项目初始化：命令执行成功', result.exitCode === 0);
-
-            // 清理测试目录
-            await fs.rm(testProjectDir, { recursive: true, force: true });
-
-        } catch (error) {
-            this.addTest('项目初始化功能', false, error.message);
-        }
-    }
-
-    // TDD测试：状态检查功能
-    async testStatusCheck() {
-        console.log('🧪 测试状态检查功能...');
-
-        try {
-            const result = await this.runCommand(this.enhancedJsPath, ['status']);
-            const hasStatusOutput = result.stdout.includes('全局配置') ||
-                                   result.stdout.includes('项目配置') ||
-                                   result.stdout.includes('可用适配器');
-
-            this.addTest('状态检查：命令执行', result.exitCode === 0);
-            this.addTest('状态检查：输出格式正确', hasStatusOutput);
-
-        } catch (error) {
-            this.addTest('状态检查功能', false, error.message);
-        }
-    }
-
-    // TDD测试：配置验证功能
-    async testConfigurationValidation() {
-        console.log('🧪 测试配置验证功能...');
-
-        try {
-            // 测试项目验证
-            const projectResult = await this.runCommand(this.enhancedJsPath, ['validate', 'project']);
-
-            // 测试全局验证
-            const globalResult = await this.runCommand(this.enhancedJsPath, ['validate', 'global']);
-
-            this.addTest('配置验证：项目验证', projectResult.exitCode === 0);
-            this.addTest('配置验证：全局验证', globalResult.exitCode === 0);
-
-        } catch (error) {
-            this.addTest('配置验证功能', false, error.message);
-        }
-    }
-
-    // TDD测试：适配器管理功能
-    async testAdapterManager() {
-        console.log('🧪 测试适配器管理功能...');
-
-        try {
-            // 测试适配器加载
-            const result = await this.runCommand(this.enhancedJsPath, ['deploy']);
-
-            this.addTest('适配器管理：部署功能', result.exitCode === 0);
-
-        } catch (error) {
-            this.addTest('适配器管理功能', false, error.message);
-        }
-    }
-
-    // TDD测试：工具扫描功能
-    async testToolScanning() {
-        console.log('🧪 测试工具扫描功能...');
-
-        try {
-            const result = await this.runCommand(this.enhancedJsPath, ['scan']);
-
-            const hasToolList = result.stdout.includes('Claude CLI') ||
-                               result.stdout.includes('Gemini CLI') ||
-                               result.stdout.includes('扫描');
-
-            const hasInstallationPrompt = result.stdout.includes('安装') ||
-                                         result.stdout.includes('缺失');
-
-            this.addTest('工具扫描：命令执行', result.exitCode === 0);
-            this.addTest('工具扫描：工具列表显示', hasToolList);
-            this.addTest('工具扫描：安装提示', hasInstallationPrompt);
-
-        } catch (error) {
-            this.addTest('工具扫描功能', false, error.message);
-        }
-    }
-
-    // TDD测试：缓存清理功能
-    async testCacheCleaning() {
-        console.log('🧪 测试缓存清理功能...');
-
-        try {
-            const result = await this.runCommand(this.enhancedJsPath, ['clean']);
-
-            this.addTest('缓存清理：命令执行', result.exitCode === 0);
-
-        } catch (error) {
-            this.addTest('缓存清理功能', false, error.message);
-        }
-    }
-
-    // 运行命令的辅助方法
-    async runCommand(scriptPath, args = [], options = {}) {
-        return new Promise((resolve) => {
-            const child = spawn('node', [scriptPath, ...args], {
-                stdio: ['pipe', 'pipe', 'pipe'],
-                cwd: process.cwd(),
-                ...options
-            });
-
-            let stdout = '';
-            let stderr = '';
-
-            child.stdout.on('data', (data) => {
-                stdout += data.toString();
-            });
-
-            child.stderr.on('data', (data) => {
-                stderr += data.toString();
-            });
-
-            child.on('close', (code) => {
-                resolve({
-                    exitCode: code,
-                    stdout: stdout,
-                    stderr: stderr
-                });
-            });
-
-            // 处理交互式命令 - 发送输入
-            if (args.includes('scan')) {
-                // 对于scan命令，发送"N"来跳过安装
-                setTimeout(() => {
-                    child.stdin.write('N\n');
-                    child.stdin.end();
-                }, 3000);
-            }
-
-            // 超时处理
-            setTimeout(() => {
-                child.kill();
-                resolve({
-                    exitCode: -1,
-                    stdout: stdout,
-                    stderr: 'Command timeout'
-                });
-            }, options.timeout || 30000);
-        });
-    }
-
-    // 检查文件是否存在
-    async fileExists(filePath) {
-        try {
-            await fs.access(filePath);
-            return true;
-        } catch {
-            return false;
-        }
-    }
-
-    // 添加测试结果
-    addTest(testName, passed, error = '') {
-        this.testResults.push({
-            test: testName,
-            passed: passed,
-            error: error
-        });
-
-        const status = passed ? '✅' : '❌';
-        console.log(`  ${status} ${testName}`);
-        if (error) {
-            console.log(`    错误: ${error}`);
-        }
-    }
-
-    // 生成测试报告
-    generateReport() {
-        const totalTests = this.testResults.length;
-        const passedTests = this.testResults.filter(r => r.passed).length;
-        const failedTests = totalTests - passedTests;
-
-        console.log('\n📊 测试报告');
-        console.log('='.repeat(50));
-        console.log(`总测试数: ${totalTests}`);
-        console.log(`通过: ${passedTests} ✅`);
-        console.log(`失败: ${failedTests} ❌`);
-        console.log(`通过率: ${((passedTests / totalTests) * 100).toFixed(1)}%`);
-
-        if (failedTests > 0) {
-            console.log('\n❌ 失败的测试:');
-            this.testResults
-                .filter(r => !r.passed)
-                .forEach(r => {
-                    console.log(`  - ${r.test}: ${r.error}`);
-                });
-        }
-
-        return {
-            total: totalTests,
-            passed: passedTests,
-            failed: failedTests,
-            passRate: (passedTests / totalTests) * 100
-        };
-    }
-
-    // 运行所有测试
-    async runAllTests() {
-        console.log('🚀 开始Enhanced Main.js功能对齐测试');
-        console.log('='.repeat(50));
-
-        await this.testCommandLineArguments();
-        await this.testProjectInitialization();
-        await this.testStatusCheck();
-        await this.testConfigurationValidation();
-        await this.testAdapterManager();
-        await this.testToolScanning();
-        await this.testCacheCleaning();
-
-        return this.generateReport();
-    }
-}
-
-// 如果直接运行此文件
-if (require.main === module) {
-    const tester = new EnhancedMainAlignTest();
-    tester.runAllTests()
-        .then(report => {
-            process.exit(report.failed > 0 ? 1 : 0);
-        })
-        .catch(error => {
-            console.error('测试执行失败:', error);
-            process.exit(1);
-        });
-}
-
-module.exports = EnhancedMainAlignTest;