🧪 Tests avec Symfony

Garantir la qualité de votre code

PHPUnit • Tests Unitaires • Tests Fonctionnels • TDD • Coverage

Formation DWWM - 2026

Au programme 📋

• 🎯 Pourquoi tester ?
• 🔬 Types de tests
• ⚗️ PHPUnit
• 🧬 Tests unitaires
• 🌐 Tests fonctionnels
• ✅ Assertions
• 🎭 Mocking et Fixtures
• 📊 Code Coverage
• 🔄 TDD
• 💡 Bonnes pratiques

Pourquoi Tester ?

L'importance des tests

Pourquoi écrire des tests ? 🤔

Scénario SANS tests 😱

Un bug en production coûte 10x plus cher qu'en développement !

Scénario AVEC tests ✅

Les tests détectent les bugs AVANT la production !

Les avantages des tests 💪

Types de Tests

Unitaires, Fonctionnels, Intégration

La pyramide des tests 🔺

Tests Unitaires 🧬

Test unitaire = Teste UNE fonction/méthode de manière ISOLÉE.

Exemple

class Calculator
{
    public function add(int $a, int $b): int
    {
        return $a + $b;
    }
}

class CalculatorTest extends TestCase
{
    public function testAdd(): void
    {
        $calc = new Calculator();
        $result = $calc->add(2, 3);
        
        $this->assertEquals(5, $result);
    }
}

Tests Fonctionnels 🌐

Test fonctionnel = Teste l'application COMPLÈTE via HTTP.

Exemple

class ArticleControllerTest extends WebTestCase
{
    public function testListArticles(): void
    {
        $client = static::createClient();
        $client->request('GET', '/articles');
        
        $this->assertResponseIsSuccessful();
        $this->assertSelectorTextContains('h1', 'Articles');
    }
}

PHPUnit

Framework de tests PHP

Installation PHPUnit 📦

1. Installer

composer require --dev symfony/test-pack

2. Structure créée

tests/
├── Unit/
├── Functional/
└── bootstrap.php

phpunit.xml.dist

3. Lancer les tests

php bin/phpunit

Premier test 🚀

Classe à tester

<?php
namespace App\Service;

class PriceCalculator
{
    public function calculateTTC(float $ht): float
    {
        return $ht * 1.20;
    }
}

Test

<?php
namespace App\Tests\Unit\Service;

use App\Service\PriceCalculator;
use PHPUnit\Framework\TestCase;

class PriceCalculatorTest extends TestCase
{
    public function testCalculateTTC(): void
    {
        // Arrange
        $calc = new PriceCalculator();
        
        // Act
        $result = $calc->calculateTTC(100);
        
        // Assert
        $this->assertEquals(120, $result);
    }
}

Assertions

Vérifier les résultats

Assertions courantes ✅

Tests Fonctionnels

Tester les contrôleurs

WebTestCase 🌐

Test d'une page

use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;

class ArticleControllerTest extends WebTestCase
{
    public function testIndex(): void
    {
        $client = static::createClient();
        $crawler = $client->request('GET', '/articles');
        
        // Vérifier code HTTP
        $this->assertResponseIsSuccessful();
        
        // Vérifier contenu
        $this->assertSelectorTextContains('h1', 'Articles');
        
        // Compter éléments
        $this->assertCount(10, $crawler->filter('.article'));
    }
}

Tester un formulaire 📝

public function testCreateArticle(): void
{
    $client = static::createClient();
    $crawler = $client->request('GET', '/article/new');
    
    // Remplir le formulaire
    $form = $crawler->selectButton('Créer')->form([
        'article[title]' => 'Mon article',
        'article[content]' => 'Contenu...'
    ]);
    
    // Soumettre
    $client->submit($form);
    
    // Vérifier redirection
    $this->assertResponseRedirects('/articles');
    
    // Suivre la redirection
    $client->followRedirect();
    
    // Vérifier le message
    $this->assertSelectorTextContains('.alert-success', 'Article créé');
}

Tester une API 🌐

public function testApiGetArticles(): void
{
    $client = static::createClient();
    $client->request('GET', '/api/articles');
    
    // Vérifier code HTTP
    $this->assertResponseIsSuccessful();
    
    // Vérifier Content-Type
    $this->assertResponseHeaderSame('Content-Type', 'application/json');
    
    // Récupérer le JSON
    $data = json_decode($client->getResponse()->getContent(), true);
    
    // Vérifier structure
    $this->assertIsArray($data);
    $this->assertArrayHasKey('id', $data[0]);
    $this->assertArrayHasKey('title', $data[0]);
}

Mocking et Fixtures

Simuler des dépendances

C'est quoi le Mocking ? 🎭

Mock = Faux objet qui simule le comportement d'un vrai objet.

Créer un Mock 🎭

public function testSendEmail(): void
{
    // Créer un mock de MailerInterface
    $mailer = $this->createMock(MailerInterface::class);
    
    // Définir le comportement
    $mailer->expects($this->once())
           ->method('send');
    
    // Utiliser le mock
    $service = new UserService($mailer);
    $service->register('test@example.com');
    
    // Le mock vérifie que send() a été appelé 1 fois
}

Fixtures de test 🎭

Fixtures = Données de test pré-définies.

Installer

composer require --dev doctrine/doctrine-fixtures-bundle

Créer des fixtures

namespace App\DataFixtures;

use App\Entity\Article;
use Doctrine\Bundle\FixturesBundle\Fixture;
use Doctrine\Persistence\ObjectManager;

class ArticleFixtures extends Fixture
{
    public function load(ObjectManager $manager): void
    {
        for ($i = 1; $i <= 10; $i++) {
            $article = new Article();
            $article->setTitle("Article $i");
            $article->setContent("Contenu $i");
            
            $manager->persist($article);
        }
        
        $manager->flush();
    }
}

Code Coverage

Mesurer la couverture de code

C'est quoi le Coverage ? 📊

Code Coverage = Pourcentage de code exécuté par les tests.

Générer le coverage

# Rapport HTML
php bin/phpunit --coverage-html var/coverage

# Rapport texte
php bin/phpunit --coverage-text

Résultat

Code Coverage Report:
  Classes: 85.00% (17/20)
  Methods: 90.00% (27/30)
  Lines:   88.50% (177/200)

TDD

Test-Driven Development

C'est quoi le TDD ? 🔄

TDD = Écrire les tests AVANT le code.

Cycle TDD (Red-Green-Refactor)

1. 🔴 Red : Écrire un test qui échoue
2. 🟢 Green : Écrire le code minimum pour passer
3. ♻️ Refactor : Améliorer le code
4. 🔁 Répéter

Exemple TDD 🔄

1. 🔴 Test (échoue)

public function testSlugify(): void
{
    $slugger = new Slugger();  // n'existe pas encore
    $result = $slugger->slugify('Hello World!');
    
    $this->assertEquals('hello-world', $result);
}

2. 🟢 Code minimum

class Slugger
{
    public function slugify(string $text): string
    {
        return strtolower(str_replace(' ', '-', trim($text, '!')));
    }
}

3. ♻️ Refactor

public function slugify(string $text): string
{
    $slug = strtolower($text);
    $slug = preg_replace('/[^a-z0-9]+/', '-', $slug);
    return trim($slug, '-');
}

Bonnes Pratiques

Écrire de bons tests

Bonnes pratiques 💡

1. Tests indépendants : Chaque test doit pouvoir s'exécuter seul
2. Un test = Une chose : Tester un seul concept par test
3. Noms explicites : testUserCannotLoginWithWrongPassword()
4. AAA (Arrange-Act-Assert) : Structure claire
5. Pas de logique : Pas de if, de boucles...
6. Tests rapides : Privilégier unitaires aux E2E
7. Nettoyer : Utiliser tearDown()

Pattern AAA 📐

public function testCalculateTTC(): void
{
    // 🔧 ARRANGE (Préparer)
    $calculator = new PriceCalculator();
    $priceHT = 100;
    
    // ⚡ ACT (Agir)
    $result = $calculator->calculateTTC($priceHT);
    
    // ✅ ASSERT (Vérifier)
    $this->assertEquals(120, $result);
}

Ce qu'on a appris

Résumé des concepts 📚

Commandes utiles 🛠️

Ressources 📚

Compétences acquises 💪

🎓 Félicitations !

Vous maîtrisez les Tests avec Symfony

Formation Symfony complète ! 🚀

Formation DWWM - 2026