Tests automatisés Laravel : De zéro à héros

A

Auteur inconnu

15 novembre 2025 • 5 min de lecture
Partager:

Introduction

Les tests automatisés sont essentiels pour maintenir la qualité du code. Voici mon approche progressive pour implémenter une stratégie de tests efficace avec Laravel.

Fondamentaux des tests Laravel

Types de tests

  • Unit tests : Test d'une fonction/classe isolée
  • Feature tests : Test d'une fonctionnalité complète
  • Integration tests : Test de l'interaction entre composants

Configuration initiale

# Installation de Pest (alternative à PHPUnit)
composer require pestphp/pest --dev
composer require pestphp/pest-plugin-laravel --dev

# Initialisation
vendor/bin/pest --init

Tests unitaires

Exemple : Service de calcul

// app/Services/PriceCalculator.php
class PriceCalculator
{
    public function calculateWithTax(float $price, float $taxRate): float
    {
        return $price * (1 + $taxRate);
    }
}

// tests/Unit/PriceCalculatorTest.php
test('calculate price with tax', function () {
    $calculator = new PriceCalculator();
    $result = $calculator->calculateWithTax(100, 0.20);
    
    expect($result)->toBe(120.0);
});

Tests fonctionnels

Test d'API REST

// tests/Feature/ProjectApiTest.php
test('can create project via api', function () {
    $user = User::factory()->create();
    
    $response = $this->actingAs($user)
        ->postJson('/api/projects', [
            'title' => 'Test Project',
            'description' => 'Description',
            'status' => 'draft'
        ]);
    
    $response->assertStatus(201)
        ->assertJson([
            'data' => [
                'title' => 'Test Project',
                'slug' => 'test-project'
            ]
        ]);
    
    $this->assertDatabaseHas('projects', [
        'title' => 'Test Project',
        'user_id' => $user->id
    ]);
});

Factories et données de test

Factory avancée

// database/factories/ProjectFactory.php
class ProjectFactory extends Factory
{
    public function definition(): array
    {
        return [
            'title' => fake()->sentence(3),
            'description' => fake()->paragraph(),
            'status' => 'published',
            'featured' => fake()->boolean(20), // 20% de chance
            'completion_date' => fake()->dateTimeBetween('-2 years'),
        ];
    }
    
    public function featured(): static
    {
        return $this->state(['featured' => true]);
    }
    
    public function draft(): static
    {
        return $this->state(['status' => 'draft']);
    }
}

Utilisation dans les tests

test('featured projects appear first', function () {
    // Créer des projets normaux et featured
    Project::factory(5)->create();
    $featuredProjects = Project::factory(3)->featured()->create();
    
    $response = $this->get('/projects');
    
    // Vérifier que les 3 premiers sont featured
    $response->assertSee($featuredProjects->first()->title);
});

Mocking et tests d'isolation

Mock d'un service externe

test('sends email notification', function () {
    Mail::fake();
    
    $user = User::factory()->create();
    $project = Project::factory()->create();
    
    // Action qui devrait envoyer un email
    app(NotificationService::class)->projectCompleted($project);
    
    Mail::assertSent(ProjectCompletedMail::class, function ($mail) use ($user) {
        return $mail->hasTo($user->email);
    });
});

Tests de base de données

Transactions automatiques

// tests/TestCase.php
abstract class TestCase extends BaseTestCase
{
    use CreatesApplication, RefreshDatabase;
    
    protected function setUp(): void
    {
        parent::setUp();
        
        // Seed par défaut pour tous les tests
        $this->seed([
            UserSeeder::class,
            CategorySeeder::class
        ]);
    }
}

TDD en pratique

Cycle Red-Green-Refactor

// 1. RED - Test qui échoue
test('can search projects by keyword', function () {
    Project::factory()->create(['title' => 'Laravel API']);
    Project::factory()->create(['title' => 'Vue.js Frontend']);
    
    $response = $this->get('/projects?search=laravel');
    
    $response->assertSee('Laravel API')
             ->assertDontSee('Vue.js Frontend');
});

// 2. GREEN - Code minimum pour passer
// Dans ProjectController
public function index(Request $request)
{
    $projects = Project::when($request->search, function ($query, $search) {
        $query->where('title', 'like', "%{$search}%");
    })->get();
    
    return view('projects.index', compact('projects'));
}

// 3. REFACTOR - Améliorer le code

Tests de performance

test('dashboard loads under 500ms', function () {
    $user = User::factory()->create();
    
    $startTime = microtime(true);
    
    $response = $this->actingAs($user)->get('/dashboard');
    
    $endTime = microtime(true);
    $executionTime = ($endTime - $startTime) * 1000; // en ms
    
    expect($executionTime)->toBeLessThan(500);
    $response->assertOk();
});

Coverage et métriques

# Générer un rapport de couverture
vendor/bin/pest --coverage --min=80

# Coverage avec HTML
vendor/bin/pest --coverage-html coverage

Conclusion

Une stratégie de tests bien pensée améliore la qualité, réduit les bugs et facilite les refactorings. Commencez petit et étendez progressivement votre couverture de tests.

A

À propos de Auteur inconnu

Développeur passionné et créateur de contenu technique.

Articles similaires

Commentaires

Soyez le premier à laisser un commentaire !

Laisser un commentaire

Votre email ne sera pas publié

Minimum 10 caractères

0 / 2000

Votre commentaire sera soumis à modération avant d'être publié. Merci de rester respectueux et constructif.

Contactez-moi sur WhatsApp