Como você testa aplicações Laravel?

Question

Accepted Answer

Laravel fornece excelente suporte de testes integrado (em PHPUnit, com a opção moderna Pest) além de helpers específicos para testes — um banco de dados de teste, testes HTTP, helpers de autenticação e fakes — tornando as aplicações altamente testáveis. Os testes são divididos em testes de feature (fluxo completo de requisição) e testes unitários (lógica isolada).

## Testes de feature — testam o fluxo completo de requisição

```php
class UserTest extends TestCase {
    use RefreshDatabase;            // fresh, migrated test database per test (isolated)

public function test_can_create_user(): void {
        $response = $this->postJson('/api/users', [    // make a real request to the app
            'name' => 'Ann', 'email' => 'ann@x.com',
        ]);
        $response->assertStatus(201)
                 ->assertJson(['name' => 'Ann']);       // assert the response
        $this->assertDatabaseHas('users', ['email' => 'ann@x.com']);   // assert the DB
    }
}
```

**Testes de feature** exercitam a pilha completa (roteamento, middleware, validação, controller, banco de dados) fazendo requisições HTTP com helpers como `get`/`postJson`, depois fazendo asserções na resposta e estado do banco de dados (`assertDatabaseHas`). Isso verifica o comportamento real da aplicação.

## Helpers de teste tornam Laravel altamente testável

```php
$this->actingAs($user)->get('/dashboard');         // authenticate as a user
User::factory()->count(10)->create();               // generate test data via factories

Mail::fake(); Mail::assertSent(WelcomeEmail::class);   // assert mail without sending
Queue::fake(); Queue::assertPushed(ProcessJob::class); // assert jobs queued, don't run them
Event::fake(); Storage::fake('s3');                    // fake events, storage, etc.
Http::fake();                                           // fake external HTTP calls
```

Os **fakes** do Laravel (`Mail::fake()`, `Queue::fake()`, `Http::fake()`, etc.) permitem que você faça asserções sobre se emails foram enviados, jobs foram enfileirados ou chamadas HTTP foram feitas — *sem* realmente executá-las, permitindo testes rápidos, isolados e determinísticos. Os helpers `actingAs` e factory tornam fácil configurar cenários de testes autenticados e ricos em dados.

## Testes unitários e Pest

```php
// unit test — isolated logic, no framework/DB
public function test_discount_calculation(): void {
    $this->assertEquals(90, (new Cart)->applyDiscount(100, 10));
}

// Pest — a modern, expressive testing syntax on top of PHPUnit (popular in Laravel)
it('creates a user', fn() => post('/users', [...])->assertCreated());
```

## Por que isso importa

Testes são essenciais para aplicações confiáveis, e o excelente suporte de testes integrado do Laravel — com helpers web-aware que tornam aplicações notavelmente testáveis — significa que entender como testar é importante tanto para qualidade de código quanto como expectativa profissional. **Testes de feature** são especialmente valiosos: ao fazer requisições HTTP reais à aplicação e fazer asserções em respostas e estado do banco de dados (com o trait `RefreshDatabase` fornecendo um banco de dados de teste isolado), eles verificam que o fluxo completo de requisição (roteamento, middleware, validação, controllers, persistência) funciona corretamente junto — testando comportamento real como os usuários o experimentam.

Os **helpers de teste e fakes** do Laravel são o que torna isso tão prático: `actingAs` para autenticação, **factories** para gerar dados de teste, e especialmente os **fakes** (`Mail::fake()`, `Queue::fake()`, `Http::fake()`, `Event::fake()`) que permitem que você faça asserções sobre se efeitos colaterais aconteceram (emails enviados, jobs enfileirados, chamadas externas feitas) *sem* realmente executá-los — permitindo testes rápidos, isolados e determinísticos de comportamento complexo.

Entender testes de feature vs testes unitários, os helpers e fakes de teste, factories para dados, e a opção moderna Pest cobre o escopo prático de testar Laravel efetivamente.

Já que Laravel fornece ferramentas de teste tão fortes e web-aware, e já que aplicações bem testadas capturam regressões e habilitam refatoração confiante, saber como aproveitar o suporte de testes do Laravel — particularmente testes de feature e os helpers fake/factory — é conhecimento importante de nível sênior que distingue desenvolvedores que constroem aplicações robustas e mantíveis daqueles que entregam código não testado e frágil, refletindo prática de engenharia profissional.