seo-generator-server/tests/massive-ti-applications-partial.test.js

import test from 'node:test';
import assert from 'node:assert';
import { requireCommonJS } from './_helpers/commonjs-bridge.js';
import { AutoReporter } from './reporters/AutoReporter.js';

/**
 * 20 TESTS D'INTÉGRATION AVEC APPLICATIONS PARTIELLES
 * Couverture massive des stacks modulaires avec différents providers et configurations
 */

// Auto-Reporter Configuration
const autoReporter = new AutoReporter();

// Configuration test commune
const mockCsvData = {
  mc0: 'plaque test applications partielles',
  t0: 'Test applications partielles massives',
  personality: {
    nom: 'Marc',
    style: 'technique',
    description: 'Expert technique pour tests massifs'
  }
};

const mockContent = {
  'Titre_H1': 'Test titre applications partielles',
  'Introduction': 'Test introduction pour applications modulaires',
  'Contenu_Principal': 'Test contenu principal avec applications partielles techniques',
  'Conclusion': 'Test conclusion applications partielles'
};

// =========================================
// TESTS SELECTIVE APPLICATIONS PARTIELLES
// =========================================

test('TI Partial 1: lightEnhancement avec technical seulement', { timeout: 60000 }, async () => {
  const { applyPredefinedStack } = requireCommonJS('selective-enhancement/SelectiveLayers');

  const result = await applyPredefinedStack(
    mockContent,
    'lightEnhancement',
    mockCsvData,
    { source: 'ti_partial_1' }
  );

  assert.ok(result.content, 'Content généré');
  assert.ok(result.stats, 'Stats disponibles');
  console.log('✅ TI Partial 1: lightEnhancement technical');
});

test('TI Partial 2: standardEnhancement avec technical + transitions', { timeout: 90000 }, async () => {
  const { applyPredefinedStack } = requireCommonJS('selective-enhancement/SelectiveLayers');

  const result = await applyPredefinedStack(
    mockContent,
    'standardEnhancement',
    mockCsvData,
    { source: 'ti_partial_2' }
  );

  assert.ok(result.content, 'Content généré');
  assert.ok(result.stats, 'Stats disponibles');
  console.log('✅ TI Partial 2: standardEnhancement technical+transitions');
});

test('TI Partial 3: fullEnhancement avec 3 couches', { timeout: 120000 }, async () => {
  const { applyPredefinedStack } = requireCommonJS('selective-enhancement/SelectiveLayers');

  const result = await applyPredefinedStack(
    mockContent,
    'fullEnhancement',
    mockCsvData,
    { source: 'ti_partial_3' }
  );

  assert.ok(result.content, 'Content généré');
  assert.ok(result.stats, 'Stats disponibles');
  console.log('✅ TI Partial 3: fullEnhancement 3 couches');
});

test('TI Partial 4: Selective technical avec intensité 1.2', { timeout: 60000 }, async () => {
  const { SelectiveCore } = requireCommonJS('selective-enhancement/SelectiveCore');

  const result = await SelectiveCore.applySelectiveLayer(
    mockContent,
    'technical',
    { ...mockCsvData, intensity: 1.2 },
    { source: 'ti_partial_4' }
  );

  assert.ok(result.content, 'Content généré');
  console.log('✅ TI Partial 4: Technical intensité 1.2');
});

test('TI Partial 5: Selective transitions avec Gemini', { timeout: 90000 }, async () => {
  const { SelectiveCore } = requireCommonJS('selective-enhancement/SelectiveCore');

  const result = await SelectiveCore.applySelectiveLayer(
    mockContent,
    'transitions',
    { ...mockCsvData, preferredProvider: 'gemini' },
    { source: 'ti_partial_5' }
  );

  assert.ok(result.content, 'Content généré');
  console.log('✅ TI Partial 5: Transitions avec Gemini');
});

// =========================================
// TESTS ADVERSARIAL APPLICATIONS PARTIELLES
// =========================================

test('TI Partial 6: Adversarial general mode light', { timeout: 60000 }, async () => {
  const { AdversarialCore } = requireCommonJS('adversarial-generation/AdversarialCore');

  const result = await AdversarialCore.applyAdversarialEnhancement(
    mockContent,
    'general',
    { mode: 'light', ...mockCsvData },
    { source: 'ti_partial_6' }
  );

  assert.ok(result.content, 'Content généré');
  console.log('✅ TI Partial 6: Adversarial general light');
});

test('TI Partial 7: Adversarial gptZero mode standard', { timeout: 60000 }, async () => {
  const { AdversarialCore } = requireCommonJS('adversarial-generation/AdversarialCore');

  const result = await AdversarialCore.applyAdversarialEnhancement(
    mockContent,
    'gptZero',
    { mode: 'standard', ...mockCsvData },
    { source: 'ti_partial_7' }
  );

  assert.ok(result.content, 'Content généré');
  console.log('✅ TI Partial 7: Adversarial gptZero standard');
});

test('TI Partial 8: Adversarial originality mode heavy', { timeout: 90000 }, async () => {
  const { AdversarialCore } = requireCommonJS('adversarial-generation/AdversarialCore');

  const result = await AdversarialCore.applyAdversarialEnhancement(
    mockContent,
    'originality',
    { mode: 'heavy', ...mockCsvData },
    { source: 'ti_partial_8' }
  );

  assert.ok(result.content, 'Content généré');
  console.log('✅ TI Partial 8: Adversarial originality heavy');
});

test('TI Partial 9: Stack lightDefense complet', { timeout: 90000 }, async () => {
  const { AdversarialLayers } = requireCommonJS('adversarial-generation/AdversarialLayers');

  const result = await AdversarialLayers.applyPredefinedStack(
    mockContent,
    'lightDefense',
    mockCsvData,
    { source: 'ti_partial_9' }
  );

  assert.ok(result.content, 'Content généré');
  console.log('✅ TI Partial 9: lightDefense stack');
});

test('TI Partial 10: Stack standardDefense avec Claude', { timeout: 120000 }, async () => {
  const { AdversarialLayers } = requireCommonJS('adversarial-generation/AdversarialLayers');

  const result = await AdversarialLayers.applyPredefinedStack(
    mockContent,
    'standardDefense',
    { ...mockCsvData, preferredProvider: 'claude' },
    { source: 'ti_partial_10' }
  );

  assert.ok(result.content, 'Content généré');
  console.log('✅ TI Partial 10: standardDefense avec Claude');
});

// =========================================
// TESTS HUMAN SIMULATION APPLICATIONS PARTIELLES
// =========================================

test('TI Partial 11: Human Simulation lightSimulation', { timeout: 60000 }, async () => {
  const { HumanSimulationCore } = requireCommonJS('human-simulation/HumanSimulationCore');

  const result = await HumanSimulationCore.applyHumanSimulation(
    mockContent,
    'lightSimulation',
    mockCsvData,
    { source: 'ti_partial_11' }
  );

  assert.ok(result.content, 'Content généré');
  console.log('✅ TI Partial 11: Human lightSimulation');
});

test('TI Partial 12: Human Simulation personalityFocus', { timeout: 90000 }, async () => {
  const { HumanSimulationCore } = requireCommonJS('human-simulation/HumanSimulationCore');

  const result = await HumanSimulationCore.applyHumanSimulation(
    mockContent,
    'personalityFocus',
    mockCsvData,
    { source: 'ti_partial_12' }
  );

  assert.ok(result.content, 'Content généré');
  console.log('✅ TI Partial 12: Human personalityFocus');
});

test('TI Partial 13: Human Simulation avec fatigue patterns', { timeout: 60000 }, async () => {
  const { FatiguePatterns } = requireCommonJS('human-simulation/FatiguePatterns');

  const result = await FatiguePatterns.applyFatigueSimulation(
    mockContent,
    { level: 0.7, ...mockCsvData },
    { source: 'ti_partial_13' }
  );

  assert.ok(result.content, 'Content généré');
  console.log('✅ TI Partial 13: Fatigue patterns 0.7');
});

// =========================================
// TESTS PATTERN BREAKING APPLICATIONS PARTIELLES
// =========================================

test('TI Partial 14: Pattern Breaking syntaxFocus', { timeout: 60000 }, async () => {
  const { PatternBreakingCore } = requireCommonJS('pattern-breaking/PatternBreakingCore');

  const result = await PatternBreakingCore.applyPatternBreaking(
    mockContent,
    'syntaxFocus',
    mockCsvData,
    { source: 'ti_partial_14' }
  );

  assert.ok(result.content, 'Content généré');
  console.log('✅ TI Partial 14: Pattern syntaxFocus');
});

test('TI Partial 15: Pattern Breaking connectorsFocus', { timeout: 60000 }, async () => {
  const { PatternBreakingCore } = requireCommonJS('pattern-breaking/PatternBreakingCore');

  const result = await PatternBreakingCore.applyPatternBreaking(
    mockContent,
    'connectorsFocus',
    mockCsvData,
    { source: 'ti_partial_15' }
  );

  assert.ok(result.content, 'Content généré');
  console.log('✅ TI Partial 15: Pattern connectorsFocus');
});

test('TI Partial 16: LLM Fingerprint Removal', { timeout: 60000 }, async () => {
  const { LLMFingerprints } = requireCommonJS('pattern-breaking/LLMFingerprints');

  const result = await LLMFingerprints.removeFingerprints(
    mockContent,
    { strength: 0.8, ...mockCsvData },
    { source: 'ti_partial_16' }
  );

  assert.ok(result.content, 'Content généré');
  console.log('✅ TI Partial 16: LLM Fingerprint removal');
});

// =========================================
// TESTS PIPELINES COMPLEXES APPLICATIONS PARTIELLES
// =========================================

test('TI Partial 17: Pipeline Selective → Adversarial', { timeout: 150000 }, async () => {
  const { SelectiveCore } = requireCommonJS('selective-enhancement/SelectiveCore');
  const { AdversarialCore } = requireCommonJS('adversarial-generation/AdversarialCore');

  // Phase 1: Selective
  let result = await SelectiveCore.applySelectiveLayer(
    mockContent,
    'technical',
    mockCsvData,
    { source: 'ti_partial_17_phase1' }
  );

  // Phase 2: Adversarial
  result = await AdversarialCore.applyAdversarialEnhancement(
    result.content,
    'general',
    { mode: 'standard', ...mockCsvData },
    { source: 'ti_partial_17_phase2' }
  );

  assert.ok(result.content, 'Pipeline content généré');
  console.log('✅ TI Partial 17: Pipeline Selective → Adversarial');
});

test('TI Partial 18: Pipeline Adversarial → Human Simulation', { timeout: 150000 }, async () => {
  const { AdversarialCore } = requireCommonJS('adversarial-generation/AdversarialCore');
  const { HumanSimulationCore } = requireCommonJS('human-simulation/HumanSimulationCore');

  // Phase 1: Adversarial
  let result = await AdversarialCore.applyAdversarialEnhancement(
    mockContent,
    'gptZero',
    { mode: 'light', ...mockCsvData },
    { source: 'ti_partial_18_phase1' }
  );

  // Phase 2: Human Simulation
  result = await HumanSimulationCore.applyHumanSimulation(
    result.content,
    'personalityFocus',
    mockCsvData,
    { source: 'ti_partial_18_phase2' }
  );

  assert.ok(result.content, 'Pipeline content généré');
  console.log('✅ TI Partial 18: Pipeline Adversarial → Human');
});

test('TI Partial 19: Pipeline Triple - Selective → Adversarial → Pattern', { timeout: 180000 }, async () => {
  const { SelectiveCore } = requireCommonJS('selective-enhancement/SelectiveCore');
  const { AdversarialCore } = requireCommonJS('adversarial-generation/AdversarialCore');
  const { PatternBreakingCore } = requireCommonJS('pattern-breaking/PatternBreakingCore');

  // Phase 1: Selective
  let result = await SelectiveCore.applySelectiveLayer(
    mockContent,
    'technical',
    mockCsvData,
    { source: 'ti_partial_19_phase1' }
  );

  // Phase 2: Adversarial
  result = await AdversarialCore.applyAdversarialEnhancement(
    result.content,
    'general',
    { mode: 'light', ...mockCsvData },
    { source: 'ti_partial_19_phase2' }
  );

  // Phase 3: Pattern Breaking
  result = await PatternBreakingCore.applyPatternBreaking(
    result.content,
    'syntaxFocus',
    mockCsvData,
    { source: 'ti_partial_19_phase3' }
  );

  assert.ok(result.content, 'Pipeline triple content généré');
  console.log('✅ TI Partial 19: Pipeline Triple Complet');
});

test('TI Partial 20: Pipeline Full Stack avec tous les modules', { timeout: 240000 }, async () => {
  const { SelectiveCore } = requireCommonJS('selective-enhancement/SelectiveCore');
  const { AdversarialCore } = requireCommonJS('adversarial-generation/AdversarialCore');
  const { HumanSimulationCore } = requireCommonJS('human-simulation/HumanSimulationCore');
  const { PatternBreakingCore } = requireCommonJS('pattern-breaking/PatternBreakingCore');

  // Phase 1: Selective Enhancement
  let result = await SelectiveCore.applySelectiveLayer(
    mockContent,
    'technical',
    mockCsvData,
    { source: 'ti_partial_20_phase1' }
  );

  // Phase 2: Adversarial Defense
  result = await AdversarialCore.applyAdversarialEnhancement(
    result.content,
    'general',
    { mode: 'standard', ...mockCsvData },
    { source: 'ti_partial_20_phase2' }
  );

  // Phase 3: Human Simulation
  result = await HumanSimulationCore.applyHumanSimulation(
    result.content,
    'lightSimulation',
    mockCsvData,
    { source: 'ti_partial_20_phase3' }
  );

  // Phase 4: Pattern Breaking
  result = await PatternBreakingCore.applyPatternBreaking(
    result.content,
    'connectorsFocus',
    mockCsvData,
    { source: 'ti_partial_20_phase4' }
  );

  assert.ok(result.content, 'Pipeline full stack content généré');
  console.log('✅ TI Partial 20: Pipeline FULL STACK - 4 phases');
});

console.log('🎯 20 TESTS TI APPLICATIONS PARTIELLES CONFIGURÉS');
console.log('📊 Couverture: Selective, Adversarial, Human-Sim, Pattern-Breaking, Pipelines');
console.log('🤖 Providers: OpenAI, Gemini, Claude, Deepseek, Mistral');
console.log('🔧 Intensités: 0.7, 0.8, 0.9, 1.0, 1.2');