Feature tests in Laravel - Deep Dive

Overview - Feature tests

What is it?

Feature tests in Laravel are automated tests that check if different parts of your application work together correctly. They simulate user actions like visiting pages, submitting forms, or interacting with APIs to ensure the app behaves as expected. These tests cover multiple layers, including routes, controllers, middleware, and views. They help catch bugs before users do.

Why it matters

Without feature tests, developers might miss bugs that only appear when different parts of the app interact. This can lead to broken pages, failed user actions, or security holes in production. Feature tests give confidence that the app works as a whole, saving time and frustration by catching problems early. They make maintaining and updating the app safer and faster.

Where it fits

Before learning feature tests, you should understand basic PHP and Laravel fundamentals like routing, controllers, and views. Knowing unit testing basics helps but is not required. After mastering feature tests, you can explore advanced testing topics like browser tests with Laravel Dusk or continuous integration setups. Feature tests sit between unit tests and full browser tests in the testing journey.

Mental Model

Core Idea

Feature tests simulate real user actions to verify that multiple parts of a Laravel app work together correctly.

Think of it like...

Feature tests are like a dress rehearsal for a play, where actors practice together to make sure the whole performance runs smoothly before the audience sees it.

┌───────────────┐
│ User Action   │
└──────┬────────┘
       │ Simulate
       ▼
┌───────────────┐
│ Feature Test  │
│ (HTTP Request)│
└──────┬────────┘
       │ Triggers
       ▼
┌───────────────┐
│ Laravel App   │
│ (Routes,      │
│ Controllers,  │
│ Middleware)   │
└──────┬────────┘
       │ Returns
       ▼
┌───────────────┐
│ Response      │
│ (View, JSON)  │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

What are Feature Tests in Laravel

Concept: Introduce the idea of feature tests as tests that check the app's behavior from the user's perspective.

Feature tests send HTTP requests to your Laravel app and check the responses. They test routes, controllers, middleware, and views working together. For example, a feature test can visit the homepage and check if it shows the welcome message.

Result

You understand that feature tests simulate user requests and check the app's full response.

Understanding that feature tests cover multiple parts of the app together helps you see why they catch bugs unit tests might miss.

2

Foundation

Setting Up Feature Tests in Laravel

Concept: Learn how to create and run a basic feature test using Laravel's built-in testing tools.

Laravel uses PHPUnit for testing. You create feature tests in the tests/Feature folder. Use the artisan command: php artisan make:test ExampleTest --feature. Inside the test, you write methods that send HTTP requests using $this->get('/'). Then use assertions like assertStatus(200) to check the response.

Result

You can create and run a simple feature test that checks a page loads successfully.

Knowing how to set up tests and run them is the first step to building reliable apps with automated checks.

3

Intermediate

Using Assertions to Verify Responses

🤔Before reading on: do you think assertSee checks HTML content or JSON data? Commit to your answer.

Concept: Learn how to use different assertions to check the content and status of HTTP responses in feature tests.

Laravel provides many assertions like assertStatus(200) to check HTTP status, assertSee('text') to check if response contains text, assertJson() to check JSON structure, and assertRedirect() to verify redirects. Combining these lets you test exactly what the user would see or receive.

Result

You can write tests that confirm pages show correct content, APIs return expected data, and redirects happen properly.

Understanding assertions lets you precisely verify app behavior from the user's view, making tests meaningful and reliable.

4

Intermediate

Testing Form Submissions and Validation

🤔Before reading on: do you think feature tests can simulate submitting forms and checking validation errors? Commit to yes or no.

Concept: Feature tests can simulate POST requests with form data and check if validation works and data is saved.

Use $this->post('/route', ['field' => 'value']) to simulate form submission. Then assert the response redirects or shows errors with assertSessionHasErrors(). You can also check database changes with assertDatabaseHas() to confirm data saved correctly.

Result

You can test user input handling, validation feedback, and database updates through feature tests.

Knowing how to test forms ensures your app handles user input safely and correctly, preventing bugs and bad data.

5

Intermediate

Using Factories and Seeders in Feature Tests

🤔Before reading on: do you think feature tests require real database data or can use fake data? Commit to your answer.

Concept: Feature tests often use model factories and seeders to create fake data for testing without affecting real data.

Laravel factories let you generate fake model instances with fake data. In tests, you can create users or posts with User::factory()->create(). This data is used during the test and rolled back after. Seeders can prepare common data sets for tests.

Result

You can write tests that rely on realistic data without manual setup, making tests faster and cleaner.

Using factories and seeders in tests helps simulate real app scenarios while keeping tests isolated and repeatable.

6

Advanced

Handling Authentication in Feature Tests

🤔Before reading on: do you think feature tests can simulate logged-in users easily? Commit to yes or no.

Concept: Feature tests can simulate authenticated users to test protected routes and actions.

Laravel provides actingAs($user) to simulate a logged-in user in tests. You create a user with a factory, then call $this->actingAs($user)->get('/dashboard'). This lets you test pages or actions that require login without manual login steps.

Result

You can test user-specific features and permissions reliably in feature tests.

Knowing how to simulate authentication in tests lets you cover security and user experience scenarios fully.

7

Expert

Optimizing Feature Tests for Speed and Reliability

🤔Before reading on: do you think running many feature tests slows down development? Commit to yes or no.

Concept: Learn techniques to keep feature tests fast and reliable in large Laravel projects.

Feature tests can be slow because they touch many parts of the app and database. Use in-memory SQLite for faster tests. Use RefreshDatabase trait to reset state. Avoid unnecessary database writes. Group related tests and run only changed tests during development. Mock external services to avoid delays.

Result

You maintain a fast test suite that developers trust and run often.

Understanding test optimization prevents slow feedback loops and keeps testing practical in real projects.

Under the Hood

Feature tests work by simulating HTTP requests inside Laravel's testing environment. When a test sends a request, Laravel boots the application, processes the request through routing, middleware, controllers, and views, then returns a response. The test captures this response and runs assertions on it. The database is usually reset between tests to keep state clean. This process mimics a real user interaction but runs entirely in code without a browser.

Why designed this way?

Laravel's feature tests were designed to provide a balance between speed and realism. Unit tests are fast but isolated; browser tests are realistic but slow. Feature tests simulate real HTTP requests without a browser, giving a practical way to test app behavior end-to-end. This design helps developers catch integration bugs early while keeping tests fast enough for daily use.

┌───────────────┐
│ Test Method   │
│ (Sends HTTP)  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Laravel App   │
│ Bootstraps    │
│ Request Flow  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Middleware    │
│ Controllers   │
│ Views         │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Response      │
│ Captured by   │
│ Test          │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do feature tests only check one function or method at a time? Commit to yes or no.

Common Belief: Feature tests only test single functions or methods in isolation.

Reality: Feature tests check how multiple parts of the app work together by simulating full HTTP requests and responses.

Why it matters: Believing this limits test scope and leads to missing bugs that happen when components interact.

Quick: Do you think feature tests require a real browser to run? Commit to yes or no.

Common Belief: Feature tests need a real browser to simulate user actions.

Reality: Feature tests run HTTP requests inside Laravel without a browser; browser tests (like Laravel Dusk) use real browsers.

Why it matters: Confusing these leads to unnecessary complexity and slower tests when simpler feature tests suffice.

Quick: Do you think feature tests always slow down development significantly? Commit to yes or no.

Common Belief: Feature tests are too slow to run often during development.

Reality: With proper setup like in-memory databases and test optimization, feature tests can run quickly and be part of daily workflows.

Why it matters: Avoiding feature tests due to speed fears reduces test coverage and increases risk of bugs.

Quick: Do you think feature tests automatically clean up database changes after each test? Commit to yes or no.

Common Belief: Feature tests do not reset database state between tests automatically.

Reality: Laravel provides traits like RefreshDatabase to reset the database after each test, keeping tests isolated.

Why it matters: Not resetting database state causes flaky tests and false failures.

Expert Zone

1

Feature tests can be combined with mocking to isolate external services while still testing app integration.

2

Using database transactions in tests can speed up resets but may not work with some database drivers or external services.

3

The order of middleware can affect feature test results, so tests can reveal subtle bugs in middleware stacking.

When NOT to use

Feature tests are not ideal for testing very small units of code where unit tests are faster and clearer. For full browser interaction like JavaScript-heavy UI, use Laravel Dusk or other browser testing tools instead. When testing external APIs, prefer mocking or integration tests to avoid flaky network calls.

Production Patterns

In real projects, feature tests cover critical user flows like login, registration, and purchases. They run in CI pipelines on every code push to catch regressions early. Teams use database factories and seeders to prepare test data. Tests are grouped by feature areas and tagged for selective runs. Mocking external APIs is common to keep tests reliable.

Connections

Unit Testing

Feature tests build on unit testing by combining multiple units to test their interaction.

Understanding unit tests helps grasp how feature tests cover broader app behavior beyond isolated functions.

Continuous Integration (CI)

Feature tests are often run automatically in CI pipelines to ensure app stability after code changes.

Knowing CI workflows shows how feature tests fit into professional development and deployment processes.

System Testing in Software Engineering

Feature tests are a form of system testing focused on verifying complete user scenarios within the app.

Recognizing feature tests as system tests helps appreciate their role in quality assurance beyond code correctness.

Common Pitfalls

#1 Writing feature tests that depend on real external APIs causing flaky failures.

Wrong approach:

$this->get('/api/data')->assertStatus(200); // calls real API

Correct approach:

Http::fake(); $this->get('/api/data')->assertStatus(200); // mocks API

Root cause:

Not isolating tests from external dependencies leads to unreliable test results.

#2 Not resetting database state between tests causing tests to fail unpredictably.

Wrong approach:

class ExampleTest extends TestCase { public function testA() { User::factory()->create(); } public function testB() { $this->assertDatabaseCount('users', 0); } }

Correct approach:

use RefreshDatabase; class ExampleTest extends TestCase { public function testA() { User::factory()->create(); } public function testB() { $this->assertDatabaseCount('users', 0); } }

Root cause:

Missing database reset trait causes leftover data to affect other tests.

#3 Testing too many things in one feature test making failures hard to diagnose.

Wrong approach:

public function testFullUserFlow() { $this->post('/register', [...]); $this->post('/login', [...]); $this->get('/dashboard')->assertSee('Welcome'); }

Correct approach:

Separate tests for registration, login, and dashboard access each focusing on one behavior.

Root cause:

Lack of test focus reduces clarity and maintainability.

Key Takeaways

Feature tests simulate real user requests to verify that multiple parts of a Laravel app work together correctly.

They help catch bugs that unit tests miss by testing routes, controllers, middleware, and views as a whole.

Laravel makes writing feature tests easy with built-in HTTP request simulation and many helpful assertions.

Using factories, authentication helpers, and database reset traits keeps feature tests reliable and maintainable.

Optimizing feature tests for speed and isolation ensures they remain practical for daily development and CI pipelines.