StillHammer
4f60de68d6
- Fix BatchProcessor constructor to avoid server blocking during startup - Add comprehensive integration tests for all modular combinations - Enhance CLAUDE.md documentation with new test commands - Update SelectiveLayers configuration for better LLM allocation - Add AutoReporter system for test automation - Include production workflow validation tests 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
315 lines
12 KiB
JavaScript
315 lines
12 KiB
JavaScript
import { AutoReporter } from '../reporters/AutoReporter.js';
|
|
// ========================================
|
|
// TESTS RAPIDES - VALIDATION SYSTÈME
|
|
// Description: Tests rapides qui valident la cohérence sans appels LLM lents
|
|
// ========================================
|
|
|
|
import assert from 'node:assert';
|
|
import { test, describe } from 'node:test';
|
|
import { requireCommonJS } from '../_helpers/commonjs-bridge.js';
|
|
|
|
// Imports système
|
|
const { StepExecutor } = requireCommonJS('StepExecutor');
|
|
const { applyPredefinedStack } = requireCommonJS('selective-enhancement/SelectiveLayers');
|
|
const { applyPredefinedStack: applyAdversarialStack } = requireCommonJS('adversarial-generation/AdversarialLayers');
|
|
const { applyPredefinedSimulation } = requireCommonJS('human-simulation/HumanSimulationLayers');
|
|
const { applyPatternBreakingStack } = requireCommonJS('pattern-breaking/PatternBreakingLayers');
|
|
|
|
|
|
// Auto-Reporter Configuration
|
|
const autoReporter = new AutoReporter();
|
|
|
|
describe('🚀 Tests RAPIDES - Validation cohérence système', () => {
|
|
|
|
const mockData = {
|
|
mc0: 'test produit',
|
|
t0: 'Test titre produit',
|
|
personality: { nom: 'Marc', style: 'professionnel' },
|
|
tMinus1: 'test ancien',
|
|
mcPlus1: 'test1,test2,test3',
|
|
tPlus1: 'Test 1,Test 2,Test 3'
|
|
};
|
|
|
|
const mockContent = {
|
|
'Titre_Test': 'Mon titre de test à traiter',
|
|
'Contenu_Test': 'Contenu de test qui doit être modifié selon les options'
|
|
};
|
|
|
|
// ========================================
|
|
// TEST 1: STEPEXECUTOR RESPECTE LES OPTIONS
|
|
// ========================================
|
|
|
|
test('🔥 CRITIQUE: StepExecutor utilise vraiment les stacks spécifiées', async () => {
|
|
console.log('🧪 Test StepExecutor options...');
|
|
|
|
const executor = new StepExecutor();
|
|
|
|
// Test que executeSelective utilise la bonne stack
|
|
try {
|
|
const lightResult = await executor.executeSelective(mockData, {
|
|
selectiveStack: 'lightEnhancement',
|
|
inputContent: mockContent
|
|
});
|
|
|
|
assert.ok(lightResult.success, 'executeSelective avec lightEnhancement doit réussir');
|
|
assert.ok(lightResult.content, 'Doit retourner du contenu');
|
|
|
|
console.log('✅ executeSelective respecte selectiveStack');
|
|
|
|
} catch (error) {
|
|
console.error('❌ Erreur executeSelective:', error.message);
|
|
throw error;
|
|
}
|
|
|
|
// Test que executeAdversarial utilise le bon mapping
|
|
try {
|
|
const adversarialResult = await executor.executeAdversarial(mockData, {
|
|
adversarialMode: 'light',
|
|
inputContent: mockContent
|
|
});
|
|
|
|
assert.ok(adversarialResult.success, 'executeAdversarial avec mode light doit réussir');
|
|
assert.ok(adversarialResult.content, 'Doit retourner du contenu');
|
|
|
|
console.log('✅ executeAdversarial respecte adversarialMode');
|
|
|
|
} catch (error) {
|
|
console.error('❌ Erreur executeAdversarial:', error.message);
|
|
throw error;
|
|
}
|
|
|
|
console.log('✅ StepExecutor respecte les options');
|
|
|
|
}, { timeout: 30000 });
|
|
|
|
// ========================================
|
|
// TEST 2: STACKS DIRECTES VS STEPEXECUTOR
|
|
// ========================================
|
|
|
|
test('🔥 CRITIQUE: Stacks directes et StepExecutor sont cohérentes', async () => {
|
|
console.log('🧪 Test cohérence stacks directes vs StepExecutor...');
|
|
|
|
// Test stack selective directe
|
|
const directSelectiveResult = await applyPredefinedStack(mockContent, 'lightEnhancement', {
|
|
csvData: mockData,
|
|
analysisMode: false
|
|
});
|
|
|
|
// Test via StepExecutor
|
|
const executor = new StepExecutor();
|
|
const stepExecutorResult = await executor.executeSelective(mockData, {
|
|
selectiveStack: 'lightEnhancement',
|
|
inputContent: mockContent
|
|
});
|
|
|
|
// Validation cohérence
|
|
assert.ok(directSelectiveResult, 'Stack directe doit retourner un résultat');
|
|
assert.ok(stepExecutorResult.success, 'StepExecutor doit réussir');
|
|
|
|
assert.ok(directSelectiveResult.content || directSelectiveResult, 'Stack directe doit avoir du contenu');
|
|
assert.ok(stepExecutorResult.content, 'StepExecutor doit avoir du contenu');
|
|
|
|
console.log('📊 Stack directe: contenu présent');
|
|
console.log('📊 StepExecutor: contenu présent');
|
|
|
|
console.log('✅ Cohérence stacks directes ↔ StepExecutor validée');
|
|
|
|
}, { timeout: 30000 });
|
|
|
|
// ========================================
|
|
// TEST 3: MAPPING MODES ADVERSARIAL
|
|
// ========================================
|
|
|
|
test('🔥 CRITIQUE: Mapping modes adversarial fonctionne', async () => {
|
|
console.log('🧪 Test mapping modes adversarial...');
|
|
|
|
const modes = [
|
|
{ mode: 'light', expectedStack: 'lightDefense' },
|
|
{ mode: 'standard', expectedStack: 'standardDefense' },
|
|
{ mode: 'heavy', expectedStack: 'heavyDefense' }
|
|
];
|
|
|
|
for (const { mode, expectedStack } of modes) {
|
|
console.log(`🧪 Test mode ${mode} → stack ${expectedStack}`);
|
|
|
|
// Test direct stack
|
|
try {
|
|
const directResult = await applyAdversarialStack(mockContent, expectedStack, {
|
|
csvData: mockData
|
|
});
|
|
|
|
assert.ok(directResult, `Stack ${expectedStack} doit fonctionner`);
|
|
console.log(`✅ Stack directe ${expectedStack}: OK`);
|
|
|
|
} catch (error) {
|
|
console.warn(`⚠️ Stack directe ${expectedStack} a échoué: ${error.message}`);
|
|
}
|
|
|
|
// Test via StepExecutor avec mapping
|
|
try {
|
|
const executor = new StepExecutor();
|
|
const stepResult = await executor.executeAdversarial(mockData, {
|
|
adversarialMode: mode,
|
|
inputContent: mockContent
|
|
});
|
|
|
|
assert.ok(stepResult.success, `StepExecutor mode ${mode} doit réussir`);
|
|
console.log(`✅ StepExecutor mode ${mode}: OK`);
|
|
|
|
} catch (error) {
|
|
console.warn(`⚠️ StepExecutor mode ${mode} a échoué: ${error.message}`);
|
|
}
|
|
}
|
|
|
|
console.log('✅ Mapping modes adversarial validé');
|
|
|
|
}, { timeout: 45000 });
|
|
|
|
// ========================================
|
|
// TEST 4: FONCTIONS IMPORTÉES CORRECTEMENT
|
|
// ========================================
|
|
|
|
test('🔥 CRITIQUE: Fonctions importées et utilisées correctement', async () => {
|
|
console.log('🧪 Test imports et utilisation fonctions...');
|
|
|
|
// Vérifier que StepExecutor importe les bonnes fonctions
|
|
const executor = new StepExecutor();
|
|
|
|
// Vérifier présence des méthodes critiques
|
|
assert.ok(typeof executor.executeSelective === 'function', 'executeSelective doit être une fonction');
|
|
assert.ok(typeof executor.executeAdversarial === 'function', 'executeAdversarial doit être une fonction');
|
|
assert.ok(typeof executor.executeHumanSimulation === 'function', 'executeHumanSimulation doit être une fonction');
|
|
assert.ok(typeof executor.executePatternBreaking === 'function', 'executePatternBreaking doit être une fonction');
|
|
|
|
// Vérifier que les fonctions de stacks directes sont accessibles
|
|
assert.ok(typeof applyPredefinedStack === 'function', 'applyPredefinedStack selective doit être accessible');
|
|
assert.ok(typeof applyAdversarialStack === 'function', 'applyAdversarialStack doit être accessible');
|
|
assert.ok(typeof applyPredefinedSimulation === 'function', 'applyPredefinedSimulation doit être accessible');
|
|
assert.ok(typeof applyPatternBreakingStack === 'function', 'applyPatternBreakingStack doit être accessible');
|
|
|
|
console.log('✅ Toutes les fonctions sont importées correctement');
|
|
|
|
// Test que les fonctions peuvent être appelées
|
|
try {
|
|
await executor.executeSelective(mockData, {
|
|
selectiveStack: 'lightEnhancement',
|
|
inputContent: { 'Test': 'contenu test' }
|
|
});
|
|
|
|
console.log('✅ executeSelective peut être appelée');
|
|
|
|
} catch (error) {
|
|
console.warn(`⚠️ executeSelective error: ${error.message}`);
|
|
}
|
|
|
|
console.log('✅ Fonctions importées et utilisables');
|
|
|
|
}, { timeout: 30000 });
|
|
|
|
// ========================================
|
|
// TEST 5: STRUCTURE DONNÉES COHÉRENTE
|
|
// ========================================
|
|
|
|
test('🔥 CRITIQUE: Structure données cohérente entre composants', async () => {
|
|
console.log('🧪 Test structure données...');
|
|
|
|
const executor = new StepExecutor();
|
|
|
|
// Test executeSelective structure de retour
|
|
const selectiveResult = await executor.executeSelective(mockData, {
|
|
selectiveStack: 'lightEnhancement',
|
|
inputContent: mockContent
|
|
});
|
|
|
|
// Vérifier structure attendue
|
|
assert.ok(selectiveResult.success !== undefined, 'Doit avoir propriété success');
|
|
assert.ok(selectiveResult.content, 'Doit avoir propriété content');
|
|
assert.ok(selectiveResult.tokensUsed !== undefined, 'Doit avoir propriété tokensUsed');
|
|
assert.ok(selectiveResult.cost !== undefined, 'Doit avoir propriété cost');
|
|
|
|
console.log('📊 Structure executeSelective:', Object.keys(selectiveResult));
|
|
|
|
// Test executeAdversarial structure de retour
|
|
const adversarialResult = await executor.executeAdversarial(mockData, {
|
|
adversarialMode: 'light',
|
|
inputContent: mockContent
|
|
});
|
|
|
|
assert.ok(adversarialResult.success !== undefined, 'Adversarial doit avoir success');
|
|
assert.ok(adversarialResult.content, 'Adversarial doit avoir content');
|
|
|
|
console.log('📊 Structure executeAdversarial:', Object.keys(adversarialResult));
|
|
|
|
// Vérifier cohérence structure
|
|
const expectedKeys = ['success', 'content', 'tokensUsed', 'cost'];
|
|
for (const key of expectedKeys) {
|
|
assert.ok(selectiveResult[key] !== undefined, `executeSelective doit avoir ${key}`);
|
|
assert.ok(adversarialResult[key] !== undefined, `executeAdversarial doit avoir ${key}`);
|
|
}
|
|
|
|
console.log('✅ Structure données cohérente entre composants');
|
|
|
|
}, { timeout: 30000 });
|
|
|
|
// ========================================
|
|
// TEST 6: CONFIGURATION DISPONIBLE
|
|
// ========================================
|
|
|
|
test('🔥 CRITIQUE: Configuration stacks et modes disponible', () => {
|
|
console.log('🧪 Test configuration disponible...');
|
|
|
|
// Vérifier qu'on peut importer les configurations
|
|
const selectiveStacks = [
|
|
'lightEnhancement',
|
|
'standardEnhancement',
|
|
'fullEnhancement',
|
|
'personalityFocus',
|
|
'fluidityFocus',
|
|
'adaptive'
|
|
];
|
|
|
|
const adversarialModes = [
|
|
'none',
|
|
'light',
|
|
'standard',
|
|
'heavy',
|
|
'adaptive'
|
|
];
|
|
|
|
const humanSimulationModes = [
|
|
'none',
|
|
'lightSimulation',
|
|
'standardSimulation',
|
|
'heavySimulation',
|
|
'adaptiveSimulation',
|
|
'personalityFocus',
|
|
'temporalFocus'
|
|
];
|
|
|
|
const patternBreakingModes = [
|
|
'none',
|
|
'lightPatternBreaking',
|
|
'standardPatternBreaking',
|
|
'heavyPatternBreaking',
|
|
'adaptivePatternBreaking',
|
|
'syntaxFocus',
|
|
'connectorsFocus'
|
|
];
|
|
|
|
// Vérifier que les modes sont cohérents avec ce qu'on attend
|
|
console.log(`📊 Selective stacks: ${selectiveStacks.length} disponibles`);
|
|
console.log(`📊 Adversarial modes: ${adversarialModes.length} disponibles`);
|
|
console.log(`📊 Human simulation modes: ${humanSimulationModes.length} disponibles`);
|
|
console.log(`📊 Pattern breaking modes: ${patternBreakingModes.length} disponibles`);
|
|
|
|
// Test que les modes de base sont présents
|
|
assert.ok(selectiveStacks.includes('lightEnhancement'), 'lightEnhancement doit être disponible');
|
|
assert.ok(selectiveStacks.includes('standardEnhancement'), 'standardEnhancement doit être disponible');
|
|
assert.ok(adversarialModes.includes('light'), 'adversarial light doit être disponible');
|
|
assert.ok(adversarialModes.includes('standard'), 'adversarial standard doit être disponible');
|
|
|
|
console.log('✅ Configuration stacks et modes disponible');
|
|
|
|
});
|
|
|
|
}); |