Tests et qualité

describe('ScoringService.calculateAnswerScore', () => {
  it('should calculate correct score for multiple choice with perfect answer', async () => {
    // Configuration Redis
    const accessCode = 'TEST123';
    await redisClient.set(`mathquest:game:${accessCode}`, JSON.stringify({
      questionUids: ['question-1', 'question-2']
    }));

    // Question parfaite
    const question = {
      uid: 'question-1',
      multipleChoiceQuestion: {
        correctAnswers: [true, false, true]
      }
    };

    const { score, timePenalty } = await ScoringService.calculateAnswerScore(
      question,
      [0, 2], // Réponses correctes
      1000,   // 1 seconde
      1000,   // temps total
      accessCode
    );

    expect(score).toBeGreaterThan(450);
    expect(timePenalty).toBeLessThan(50);
  });
});

describe('Tournament Mode Scoring', () => {
  it('should handle live vs deferred tournaments differently', async () => {
    // Test de la logique de différenciation
    const liveGame = { playMode: 'tournament', status: 'active' };
    const deferredGame = { playMode: 'tournament', status: 'completed' };

    expect(liveGame.status).toBe('active');
    expect(deferredGame.status).toBe('completed');

    // Vérification des clés Redis
    const liveKey = `mathquest:game:leaderboard:${accessCode}`;
    const deferredKey = `deferred_session:${accessCode}:${userId}:1`;

    expect(liveKey).not.toBe(deferredKey);
  });
});

describe('Timer Edge Cases', () => {
  it('should handle timer restart penalties correctly', async () => {
    // Test des pénalités de redémarrage
    const restartCount = 2;
    const basePenalty = 0.5; // 50% pour 3ème essai

    expect(restartCount).toBe(2);
    expect(basePenalty).toBe(0.5);
  });

  it('should cap penalty at 50% for excessive restarts', async () => {
    // Test du plafond de pénalité
    const excessiveRestarts = 10;
    const maxPenalty = 0.5;

    expect(excessiveRestarts).toBeGreaterThan(2);
    expect(maxPenalty).toBe(0.5);
  });
});

import { redisClient } from '../../src/config/redis';

// Nettoyage avant/après chaque test
beforeEach(async () => {
  await redisClient.flushall();
});

afterEach(async () => {
  await redisClient.flushall();
});

import { prisma } from '../../src/db/prisma';

// Mock du client Prisma
jest.mock('../../src/db/prisma', () => ({
  prisma: {
    user: {
      findUnique: jest.fn(),
      create: jest.fn()
    }
  }
}));

// Utilitaires pour créer des données de test
export const createTestUser = (overrides = {}) => ({
  id: 'test-user-id',
  username: 'testuser',
  email: 'test@example.com',
  role: 'STUDENT',
  ...overrides
});

export const createTestGame = (overrides = {}) => ({
  id: 'test-game-id',
  name: 'Test Game',
  accessCode: 'TEST123',
  playMode: 'quiz',
  status: 'active',
  ...overrides
});

describe('Performance Tests', () => {
  it('should handle 1000 concurrent users', async () => {
    const startTime = Date.now();

    // Simulation de charge
    const promises = Array(1000).fill().map(async () => {
      return ScoringService.calculateAnswerScore(/*...*/);
    });

    await Promise.all(promises);
    const endTime = Date.now();

    expect(endTime - startTime).toBeLessThan(5000); // < 5 secondes
  });
});

describe('Socket.IO Load Tests', () => {
  it('should handle multiple simultaneous connections', async () => {
    const connections = 100;

    // Créer plusieurs connexions Socket.IO
    const sockets = [];
    for (let i = 0; i < connections; i++) {
      const socket = io('http://localhost:3007');
      sockets.push(socket);
    }

    // Vérifier que toutes les connexions sont établies
    await Promise.all(sockets.map(socket =>
      new Promise(resolve => socket.on('connect', resolve))
    ));

    expect(sockets.length).toBe(connections);
  });
});

import { defineConfig } from '@playwright/test';

export default defineConfig({
  testDir: './tests',
  use: {
    baseURL: 'http://localhost:3000',
    browserName: 'chromium',
    headless: true,
    screenshot: 'only-on-failure'
  },
  projects: [
    {
      name: 'chromium',
      use: { browserName: 'chromium' }
    }
  ]
});

import { test, expect } from '@playwright/test';

test('complete quiz workflow', async ({ page }) => {
  // Connexion
  await page.goto('/');
  await page.fill('[data-testid="email"]', 'teacher@test.com');
  await page.fill('[data-testid="password"]', 'password');
  await page.click('[data-testid="login-button"]');

  // Création d'un quiz
  await page.click('[data-testid="create-quiz"]');
  await page.fill('[data-testid="quiz-name"]', 'Test Quiz');
  await page.click('[data-testid="save-quiz"]');

  // Vérification
  await expect(page.locator('[data-testid="quiz-list"]')).toContainText('Test Quiz');
});

// Logs détaillés pour le debugging
console.log('Test data:', { userId, gameId, score });

// Utilisation du logger de l'application
import createLogger from '../../src/utils/logger';
const logger = createLogger('TestDebug');
logger.info('Test execution details', { context });

// Chaque test est isolé
beforeEach(async () => {
  await redisClient.flushall();
  await prisma.user.deleteMany();
});

afterEach(async () => {
  await redisClient.flushall();
});

// Extraire les données de test communes
const TEST_USERS = {
  teacher: { id: 'teacher-1', role: 'TEACHER' },
  student: { id: 'student-1', role: 'STUDENT' }
};

// Utiliser des factories
const createTestGame = (overrides) => ({
  id: 'game-1',
  name: 'Test Game',
  ...overrides
});

// Marquer les tests legacy
describe.skip('Legacy Tests', () => {
  it('should be updated to new patterns', () => {
    // TODO: Refactor this test
  });
});