DEV Community: Islam A-Elwafa

Effortless Laravel Performance Testing — Without Leaving PHP

Islam A-Elwafa — Thu, 14 Aug 2025 13:25:21 +0000

When your Laravel app hits real traffic, will it fly… or will it fall over?

Most load-testing tools make you jump through hoops — learn a new scripting language, spin up external services, or fight with configs that feel like they belong to another ecosystem.

That’s why I built the Laravel Performance Testing package:

a native, PHP-first way to run load and stress tests right inside your Laravel project — powered by the Volt Test PHP SDK.

You write your tests in plain PHP, keep them version-controlled with your codebase, and run them with a single Artisan command. No context-switching. No external scripts. Just Laravel, PHP, and the performance insights you need before your users find the bottlenecks.

Why I Created This Package

About a month ago, I released this package to make performance testing in Laravel:

Easier – no external scripts or frameworks to learn.
Native – tests live inside your Laravel project.
Flexible – from simple single-URL load tests to complex multi-step scenarios.

✨ Features

Laravel-friendly integration – Works seamlessly with routes, middleware, and config.
Artisan commands – Generate and run tests directly from the CLI.
Automatic route discovery – Quickly build test scenarios from your existing routes.
Variable extraction – Reuse cookies, headers, JSON fields, and HTML values between steps.
Data-driven testing – Feed test data from CSV files for realistic simulations.
Detailed metrics – Success rate, RPS, average latency, P95 latency, and more.
Report storage – Save test results for later analysis.

🚀 Installation

composer require volt-test/laravel-performance-testing

Publish the configuration file:

php artisan vendor:publish --tag=volttest-config

This creates config/volttest.php where you can tweak settings like default virtual users, duration, and report paths.

⚡ Quick Start

Run a quick performance test without writing any code:

php artisan volttest:run https://example.com/api/login --users=100 --method=POST --body='{"email":"test@example.com","password":"secret"}'

Or, create a reusable test class:

php artisan volttest:make ExampleTest

This generates app/VoltTests/ExampleTest.php:

namespace App\VoltTests;

use VoltTest\Laravel\Contracts\VoltTestCase;
use VoltTest\Laravel\VoltTestManager;

class ExampleTest implements VoltTestCase
{
    public function define(VoltTestManager $manager): void
    {
        $manager->scenario('ExampleTest')
            ->step('Visit Home Page')
            ->get('https://example.com')
            ->validateStatus('success', 200);
    }
}

Run it with:

php artisan volttest:run ExampleTest --users=50 --duration=30

🎯 Route-Based Test Generation

Skip manual coding by generating tests from your Laravel routes:

# Include all routes
php artisan volttest:make ApiTest --routes

# Filter by pattern
php artisan volttest:make ApiTest --routes --filter="api/*"

# Only GET routes
php artisan volttest:make ApiTest --routes --method=GET

# Only authenticated routes
php artisan volttest:make ApiTest --routes --auth

# Interactive selection
php artisan volttest:make ApiTest --routes --select

📊 Data-Driven Testing

Simulate realistic usage with CSV files.

users.csv

name,email,password
John Doe,user1@example.com,password123
Jane Smith,user2@example.com,password456

Test definition:

$manager->scenario('RegisterTest')
    ->dataSource('users.csv')
    ->step('Register User')
    ->post('/register', [
        'name' => '${name}',
        'email' => '${email}',
        'password' => '${password}',
    ]);

🔍 Extract & Reuse Values

CSRF token from HTML

$scenario->step('Get Login Page')
    ->get('/login')
    ->extractCsrfToken('csrf_token');

$scenario->step('Submit Login')
    ->post('/login', [
        '_token' => '${csrf_token}',
        'email'  => 'user@example.com',
        'password' => 'secret',
    ]);

JSON field

$scenario->step('Get User')
    ->get('/api/user')
    ->extractJson('user_id', 'data.id');

Header

$scenario->step('Get Token')
    ->get('/auth')
    ->extractHeader('Authorization', 'Bearer ${token}');

📈 Analyzing Results

After running a test, you’ll see metrics such as:

✅ Success rate
⚡ Requests per second (RPS)
⏱ Average & P95 latency
⌛ Duration
❌ Errors

If save_reports is enabled, detailed reports are stored in:

storage/volttest/reports

🏁 Conclusion

With Laravel Performance Testing powered by the Volt Test PHP SDK, you can:

Keep performance tests inside your Laravel project.
Run them with one Artisan command.
Get actionable performance metrics before your users notice slowdowns.

📚 Docs: Laravel Performance Testing on GitHub

📦 Volt Test PHP SDK: php.volt-test.com

💡 Pro Tip: Integrate Volt-Test into your CI pipeline to catch performance regressions before they hit production.

Stress Testing Laravel Applications with VoltTest (Web UI Flow)

Islam A-Elwafa — Fri, 25 Jul 2025 19:46:36 +0000

Introduction

In this tutorial, we will explore how to perform stress testing on a Laravel application using the VoltTest PHP SDK. You will learn how to:

Simulate multiple users interacting with your Laravel application.
Test user registration and authentication workflows.
Measure application performance under load.
Extract dynamic values like CSRF tokens during test execution.
Use a CSV file as a data source for testing.
Analyze and optimize performance bottlenecks.

By the end of this guide, you will be able to confidently run automated performance tests to ensure your Laravel app is scalable and resilient.

Prerequisites

Ensure you have the following:

A running Laravel application
PHP 8.0 or higher
Composer installed

Installing VoltTest PHP SDK

First, install the VoltTest PHP SDK via Composer in your Laravel project:

composer require volt-test/php-sdk

Or clone the repository:

git clone https://github.com/volt-test/php-sdk.git
cd php-sdk
composer install

For Windows users, Visit the installation guide here

Creating Test Data

For a realistic test, create a CSV file (users.csv) with test user data:

email,password
user1@example.com,password123
user2@example.com,password123
user3@example.com,password123
user4@example.com,password123
user5@example.com,password123

Place this file in your project directory.

Writing the Stress Test

Create a file named laravel_stress_test.php in your project root and add the following script (or you can use the laravel's command):

<?php

require 'vendor/autoload.php';

use VoltTest\DataSourceConfiguration;
use VoltTest\VoltTest;

// Define test
$test = new VoltTest(
'Laravel User Flow',
'Tests home page visit, user registration, and dashboard access'
);

// Configure test parameters
$test
->setVirtualUsers(5)
->setDuration('60s') // Optional: Set test duration
->setRampUp('10s') // Optional: Set ramp-up time
->setHttpDebug(true); // Enable HTTP debug logging for checking requests before sending the all requests

// Create test scenario
$userFlowScenario = $test->scenario('User Registration Flow')
->autoHandleCookies(); // Automatically handle cookies without extract them

// Set up data source
$userFlowScenario->setDataSourceConfiguration(
new DataSourceConfiguration(__Dir__ . '/users.csv', 'unique', true) // Load data from CSV file, should be the full path
);

// Step 1: Visit home page
$userFlowScenario->step('Visit Home Page')
->get('http://localhost:8000')
->header('Accept', 'text/html')
->validateStatus('home_page_loaded', 200)
->setThinkTime('2s');

// Step 2: Visit register page and extract CSRF token
$userFlowScenario->step('Visit Register Page')
->get('http://localhost:8000/register')
->header('Accept', 'text/html')
->extractFromHtml('csrf_token', 'input[name="_token"]', 'value')
->validateStatus('register_page_loaded', 200)
->setThinkTime('2s');

// Step 3: Submit registration form
$userFlowScenario->step('Submit Registration')
->post(
'http://localhost:8000/register',
'_token=${csrf_token}&name=Test User&email=${email}&password=${password}&password_confirmation=${password}'
)
->header('Content-Type', 'application/x-www-form-urlencoded')
->validateStatus('registration_successful', 302)
->setThinkTime('1s');

// Step 4: Access dashboard
$userFlowScenario->step('Visit Dashboard')
->get('http://localhost:8000/dashboard')
->header('Accept', 'text/html')
->validateStatus('dashboard_loaded', 200)
->setThinkTime('3s');

// Run test
$result = $test->run(true); // true enables real-time progress output

// Display results summary in case you turned off the real-time progress output
echo "\n\nTest Results Summary:\n";
echo "====================\n";
echo "Total Requests: " . $result->getTotalRequests() . "\n";
echo "Success Rate: " . $result->getSuccessRate() . "%\n";
echo "Requests/second: " . $result->getRequestsPerSecond() . "\n";
echo "Min Response Time: " . $result->getMinResponseTime() . "\n";
echo "Max Response Time: " . $result->getMaxResponseTime() . "\n";
echo "Avg Response Time: " . $result->getAvgResponseTime() . "\n";
echo "P95 Response Time: " . $result->getP95ResponseTime() . "\n";

Code Explanation

The stress test script simulates multiple users interacting with a Laravel web application. Here’s how it works:

Initialize VoltTest:

$test = new VoltTest(
'Laravel User Flow',
'Tests home page visit, user registration, and dashboard access'
);

- Creates a new test instance with a descriptive name.

Configure test parameters:

$test
->setVirtualUsers(5)
->setDuration('60s')
->setRampUp('10s')
->setHttpDebug(true);

5 virtual users: Simulate 5 concurrent users.
Running the test for 60 seconds: Optional - you can remove this line to run the test and finish when all virtual users finish their scenarios.
Ramping up over 10 seconds: Optional - you can remove this line to start all virtual users at the same time.
Enables HTTP debug logging: Optional - Inspect requests while sending them.

Create a test scenario:

$userFlowScenario = $test->scenario('User Registration Flow')
->autoHandleCookies();

Creates a scenario for user registration flow.
autoHandleCookies(): Automatically handles cookies without extracting them.

Set up data source:

$userFlowScenario->setDataSourceConfiguration(
new DataSourceConfiguration(__Dir__ . '/users.csv', 'unique', true)
);

Loads user data from users.csv file. To simulate different users for each virtual user.

Define test steps:

$userFlowScenario->step('Visit Home Page')
->get('http://localhost:8000')
->header('Accept', 'text/html')
->validateStatus('home_page_loaded', 200)
->setThinkTime('2s');

Visit Home Page: Sends a GET request to the home page.
Accept header: Optional - Specifies the expected response content type.
Validate Status: Optional - Checks if the response status is 200.
Think Time: Optional - Simulates user thinking time before the next step, so the virtual user will wait 2s before execute the next request.

Extract CSRF token from registration page:

$userFlowScenario->step('Visit Register Page')
->get('http://localhost:8000/register')
->header('Accept', 'text/html')
->extractFromHtml('csrf_token', 'input[name="_token"]', 'value')
->validateStatus('register_page_loaded', 200)
->setThinkTime('2s');

Visits the registration page.
Extracts the CSRF token from the HTML response. The token is stored in the variable ${csrf_token}.
- The way to extract the token is by using the extractFromHtml method, which takes the token name, the selector, and the attribute name.

Submit registration form:

$userFlowScenario->step('Submit Registration')
->post(
'http://localhost:8000/register',
'_token=${csrf_token}&name=Test User&email=${email}&password=${password}&password_confirmation=${password}'
)
->header('Content-Type', 'application/x-www-form-urlencoded')
->validateStatus('registration_successful', 302)
->setThinkTime('1s');

Submits the registration form with the extracted CSRF token and user data.
Validates the response status code.
Sets a 1-second think time before the next step.
The ${email} and ${password} variables are replaced with values from the CSV file.
The ${csrf_token} variable is replaced with the extracted CSRF token.
The validateStatus method checks if the response status is 302 (redirect).
The setThinkTime method simulates user thinking time before the next step.

Access dashboard:

$userFlowScenario->step('Visit Dashboard')
->get('http://localhost:8000/dashboard')
->header('Accept', 'text/html')
->validateStatus('dashboard_loaded', 200)
->setThinkTime('3s');

Ensures successful login by verifying dashboard access.

Run the test:

$result = $test->run(true);

Executes the test with real-time progress output.

Running the Test

Execute the script:

php laravel_stress_test.php

You'll see real-time progress, followed by a summary of test results.

Analyzing Results

Key Metrics:

Success Rate: Should be as close to 100% as possible
Response Times: Lower is better
Requests per Second: Higher means better scalability

Common Issues & Fixes

Low Success Rate

Possible Cause: Server overload
Solution: Reduce virtual users or optimize queries

High Response Times

Possible Cause: Database bottlenecks
Solution: Optimize queries, enable caching

CSRF Token Extraction Fails

Possible Cause: HTML structure changes
Solution: Update the selector

Next Steps

Expand tests to cover more user flows
Test with more virtual users
Automate stress tests in CI/CD pipelines

Conclusion

Using VoltTest for stress testing helps identify Laravel application bottlenecks before they impact users. Regular testing ensures scalability and reliability.

Stay tuned for our next guide on Stress Testing Laravel APIs with VoltTest!

Happy testing!

Get in Touch

For questions, discussions, or contributions, feel free to open an issue or start a discussion on the Volt-Test GitHub repository:
https://github.com/volt-test/php-sdk