Tests unitaires et qualité de code

Pourquoi écrire des tests unitaires ?

• Garantir le bon fonctionnement du code lors des évolutions
• Faciliter la maintenance et la refactorisation
• Documenter le comportement attendu
• Détecter les bugs avant la mise en production
• Augmenter la confiance dans votre code

Installation de PHPUnit

• Via Composer (recommandé) : composer require --dev phpunit/phpunit
• Ou globalement : composer global require phpunit/phpunit
• Pour les débutants : commencez par créer un projet avec composer init puis installez PHPUnit

// Calculator.php
class Calculator {
    public function add($a, $b) {
        return $a + $b;
    }
    
    public function subtract($a, $b) {
        return $a - $b;
    }
    
    public function multiply($a, $b) {
        return $a * $b;
    }
    
    public function divide($a, $b) {
        if ($b == 0) {
            throw new InvalidArgumentException('Division par zéro impossible');
        }
        return $a / $b;
    }
}

// tests/CalculatorTest.php
use PHPUnit\Framework\TestCase;

class CalculatorTest extends TestCase {
    private $calculator;
    
    // Cette méthode s'exécute avant chaque test
    protected function setUp(): void {
        $this->calculator = new Calculator();
    }
    
    // Le nom des méthodes de test doit commencer par "test"
    public function testAdditionReturnsCorrectResult() {
        $result = $this->calculator->add(2, 2);
        $this->assertEquals(4, $result);
    }
    
    public function testSubtractionReturnsCorrectResult() {
        $result = $this->calculator->subtract(5, 2);
        $this->assertEquals(3, $result);
    }
    
    public function testMultiplicationReturnsCorrectResult() {
        $result = $this->calculator->multiply(3, 4);
        $this->assertEquals(12, $result);
    }
    
    public function testDivisionReturnsCorrectResult() {
        $result = $this->calculator->divide(10, 2);
        $this->assertEquals(5, $result);
    }
    
    public function testDivisionByZeroThrowsException() {
        $this->expectException(InvalidArgumentException::class);
        $this->calculator->divide(10, 0);
    }
}

# Exécuter tous les tests
./vendor/bin/phpunit tests/

# Exécuter un fichier de test spécifique
./vendor/bin/phpunit tests/CalculatorTest.php

# Exécuter une méthode de test spécifique
./vendor/bin/phpunit --filter testAdditionReturnsCorrectResult tests/CalculatorTest.php

PHPUnit 9.5.28 by Sebastian Bergmann and contributors.

..... 5 / 5 (100%)

Time: 00:00.003, Memory: 4.00 MB

OK (5 tests, 5 assertions)

Bonnes pratiques pour nommer vos tests

• Utilisez des noms descriptifs : testAdditionReturnsCorrectResult()
• Suivez un format comme test[Méthode][Scenario][Résultat]()
• Exemple : testDivisionByZeroThrowsException()

// Vérifier si une valeur est vraie ou fausse
$this->assertTrue($valeur);
$this->assertFalse($valeur);

// Vérifier une égalité
$this->assertEquals(4, 2 + 2);
$this->assertSame(4, $resultat); // égalité stricte (===)

// Vérifier si une valeur est null
$this->assertNull($valeur);
$this->assertNotNull($valeur);

// Vérifier un tableau
$this->assertCount(3, $tableau);
$this->assertContains('pomme', $fruits);

// Vérifier si une chaîne contient une autre
$this->assertStringContainsString('abc', $texte);

// Vérifier si une chaîne commence par
$this->assertStringStartsWith('Bonjour', $message);

// Vérifier si une chaîne se termine par
$this->assertStringEndsWith('.jpg', $nomFichier);

// Vérifier avec une expression régulière
$this->assertMatchesRegularExpression('/^\d{4}-\d{2}-\d{2}$/', $date);

class UserServiceTest extends TestCase {
    public function testGetFullName() {
        // Créer un mock du Repository
        $mockRepository = $this->createMock(UserRepository::class);
        
        // Configurer le comportement du mock
        $mockRepository->method('findById')
            ->with(123) // On s'attend à ce que le paramètre soit 123
            ->willReturn([
                'firstname' => 'Jean',
                'lastname' => 'Dupont'
            ]);
        
        // Injecter le mock dans le service à tester
        $userService = new UserService($mockRepository);
        
        // Tester le service
        $fullName = $userService->getFullNameById(123);
        $this->assertEquals('Jean Dupont', $fullName);
    }
}

Générer un rapport de couverture

# Vous aurez besoin de Xdebug ou PCOV installé
./vendor/bin/phpunit --coverage-html coverage/ tests/

Cette commande générera un dossier coverage/ avec un rapport HTML détaillé montrant :

• Le pourcentage global de couverture
• Les lignes couvertes (vert) et non couvertes (rouge)
• Les chemins d'exécution manquants

Visez une couverture > 80% pour un code de qualité, mais souvenez-vous que la qualité prime sur la quantité.

Exemple de configuration GitHub Actions

# Nom du workflow
name: Tests PHP

# Déclencheurs
on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main, develop ]

# Jobs à exécuter
jobs:
  tests:
    name: Tests unitaires
    runs-on: ubuntu-latest
    
    steps:
      # Récupérer le code
      - uses: actions/checkout@v3
      
      # Configurer PHP
      - name: Configurer PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: '8.2'
          extensions: mbstring, xml, ctype, iconv, intl, pdo_sqlite, dom, filter
          coverage: xdebug
      
      # Installer les dépendances
      - name: Installer les dépendances
        run: composer install --prefer-dist
      
      # Exécuter les tests
      - name: Exécuter les tests
        run: ./vendor/bin/phpunit
      
      # Générer un rapport de couverture
      - name: Générer la couverture de code
        run: ./vendor/bin/phpunit --coverage-clover coverage.xml
      
      # Publier la couverture (optionnel)
      - name: Publier la couverture sur Codecov
        uses: codecov/codecov-action@v3
        with:
          file: ./coverage.xml

Ce workflow :

1. Se déclenche à chaque push sur main/develop ou lors d'une pull request
2. Configure PHP 8.2 avec Xdebug pour la couverture de code
3. Installe les dépendances via Composer
4. Exécute les tests PHPUnit
5. Génère et publie un rapport de couverture de code

Badges de statut

Ajoutez un badge dans votre README.md pour afficher l'état de vos tests :

[![Tests PHP](https://github.com/username/repo/actions/workflows/tests.yml/badge.svg)](https://github.com/username/repo/actions/workflows/tests.yml)
[![Couverture de code](https://codecov.io/gh/username/repo/branch/main/graph/badge.svg)](https://codecov.io/gh/username/repo)

Ces badges s'afficheront ainsi :

• Fast (Rapide) : Les tests doivent s'exécuter rapidement pour être utilisés souvent.
• Independent (Indépendant) : Chaque test doit pouvoir s'exécuter seul, sans dépendre d'autres tests.
• Repeatable (Reproductible) : Les tests doivent donner le même résultat à chaque exécution.
• Self-validating (Auto-validant) : Les tests doivent déterminer eux-mêmes s'ils réussissent ou échouent.
• Timely (Opportun) : Idéalement, écrivez les tests avant ou en même temps que le code.

mon-projet/
├── src/
│   └── Calculator.php
├── tests/
│   └── CalculatorTest.php
├── composer.json
└── phpunit.xml

<?xml version="1.0" encoding="UTF-8"?>
<phpunit colors="true">
    <testsuites>
        <testsuite name="Mon Application">
            <directory>tests</directory>
        </testsuite>
    </testsuites>
</phpunit>

📚 Documentation et tutoriels

• Documentation officielle PHPUnit
• Guide PHPUnit en français
• PHP The Right Way - Tests
• Tutoriel vidéo : PHPUnit pour débutants

🛠 Outils complémentaires

• GitHub Action Setup PHP
• Infection - Tests de mutation pour PHP
• Codeception - Framework de tests PHP complet
• Pest - Framework de tests élégant basé sur PHPUnit

💻 Code de départ pour l'exercice 1

// src/ShoppingCart.php
class ShoppingCart {
    private $items = [];
    
    public function addItem($item, $price, $quantity = 1) {
        if ($price <= 0) {
            throw new InvalidArgumentException("Le prix doit être positif");
        }
        
        if ($quantity <= 0) {
            throw new InvalidArgumentException("La quantité doit être positive");
        }
        
        $this->items[$item] = [
            'price' => $price,
            'quantity' => $quantity
        ];
    }
    
    // À compléter : removeItem(), getTotal(), clear()
}