Volt-Test was built to make load testing simple and native for PHP developers, and this new release takes it one step further. You can now test your Laravel APIs under load using the same PHPUnit environment you already use for your feature and unit tests.

Why PHPUnit Integration Matters​

Most Laravel developers already rely on PHPUnit for testing logic and features. Now, you can also measure your app’s behavior under load without leaving that familiar workflow.

This means:

• No switching to external tools or YAML scripts.
• Run load tests in your CI/CD pipeline.
• Catch performance regressions automatically.
• Keep your load testing code version-controlled alongside your application tests.

Installation​

If you already use the package, update it:

composer update

or install fresh

composer require volt-test/laravel-performance-testing

you can check the package configuration options and how you can use in the blog post Effortless Laravel Performance Testing with Volt Test PHP SDK.

Configure PHPUnit​

In your phpunit.xml file, add a new testsuite for performance tests:

<testsuites>
    ....
    <testsuite name="Performance">
        <directory>tests/Performance</directory>
    </testsuite>
</testsuites>

This tells PHPUnit to look for performance tests in the tests/Performance directory. Additionally, you can set environment variables for Volt-Test in the phpunit.xml file:

<php>
 <env name="VOLTTEST_BASE_PATH" value="."/>
<env name="VOLTTEST_SERVER_PORT" value="8009"/>
<env name="VOLTTEST_ENABLE_SERVER_MANAGEMENT" value="true"/>
<env name="VOLTTEST_DEBUG_FOR_SERVER_MANAGEMENT" value="true"/>
</php>

Environment variables Explanation:

• VOLTTEST_BASE_PATH: The base path for your Laravel application. (usually .)
• VOLTTEST_SERVER_PORT: The Preferred port where your Laravel app will run during tests.
• VOLTTEST_ENABLE_SERVER_MANAGEMENT: Enables automatic server management during tests without run you server (usually using this during you writing the test ).
• VOLTTEST_DEBUG_FOR_SERVER_MANAGEMENT: Enables debug logs for server management (useful for troubleshooting).

Alternatively, you can set these variables in your system environment or .env or .env.testing file.

VOLTTEST_BASE_PATH=.
VOLTTEST_SERVER_PORT=8009
VOLTTEST_ENABLE_SERVER_MANAGEMENT=true
VOLTTEST_DEBUG_FOR_SERVER_MANAGEMENT=true

Writing Load Tests with PHPUnit and Volt-Test​

Once installed and configure, you can create a new test file inside your Laravel app’s tests/Performance directory:

<?php
namespace Tests\Performance;

use VoltTest\Laravel\Testing\PerformanceTestCase;

class HomePageLoadTest extends PerformanceTestCase
{
    protected static bool $enableServerManagement = true;

    public function testHomePageUnderLoad()
    {
        // Run a load test on the home page with 50 virtual users
        $result = $this->loadTestUrl('/', [
            'virtual_users' => 50,
        ]);
        // Assert that the success rate is above 99%
        $this->assertVTSuccessful($result, 99);
        // Assert that the 95th percentile response time is below 150ms
        $this->assertVTP95ResponseTime($result, 150);
    }
}

In this example:

• We create a HomePageLoadTest class that extends PerformanceTestCase.
• We enable server management by setting the static property $enableServerManagement to true. So Volt-Test will automatically start and stop your Laravel server during the test.
• We define a test method testHomePageUnderLoad that runs a load test on the home page (/) with 50 virtual users.
• We use assertions to verify that the success rate is above 99% and that the 95th percentile response time is below or equal 150 milliseconds.

Running Your Load Tests​

To execute your load tests, run PHPUnit with the performance testsuite:

vendor/bin/phpunit --testsuite Performance

This command will run all tests in the tests/Performance directory, including your load tests. You can also run a specific test file:

vendor/bin/phpunit tests/Performance/HomePageLoadTest.php

Example Output​

PHPUnit interleaves Volt-Test performance reports with your regular assertions—for example:

$ vendor/bin/phpunit --testsuite Performance
PHPUnit 11.5.44 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.4.15
Configuration: /path/to/app/phpunit.xml

  Performance Report: testHomePageUnderLoad
  Total Requests:      50
  Success Rate:        100.00%
  Requests/Sec (RPS):  346.19
  Avg Latency:         74.2426ms
  ----------------------------------------------------------------------
                                                                 1 / 1 (100%)

Time: 00:01.524, Memory: 30.00 MB

if you have set up your CI/CD pipeline to run PHPUnit tests, your load tests will automatically be included in the test suite.

if you need to run the test to you staging or production environment, you can set the VOLTTEST_BASE_URL environment variable before running PHPUnit:

As normal phpunit if assertion of the load test failed the test will be marked as failed. so it can help you to catch performance regressions early in your development process.

Advanced Load Testing Scenarios (Reusing Existing VoltTest Classes)​

If you've already created load tests using Volt-Test's native syntax (covered in Effortless Laravel Performance Testing with Volt Test PHP SDK), you can now reuse those classes inside your PHPUnit tests.

Here is an example:

<?php

namespace App\VoltTests;

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

class RegisterAndCheckoutTest implements VoltTestCase
{
    $scenario = $manager->scenario('EcommerceAPITest')
            ->dataSource('registration_users.csv', 'sequential');

        // Step 1 : Api.register
        $scenario->step('Api.register')
            ->post('/api/v1/register', [
                'name' => '${name}',
                'email' => '${email}',
                'password' => '${password}',
                'password_confirmation' => '${password}',
            ], ['Content-Type' => 'application/json', 'Accept' => 'application/json'])
            ->extractJson('token', 'token.access_token') // Extract the token for subsequent requests
            ->expectStatus(201);

        // Step 2 : Api.products.index
        $scenario->step('Api.products.index')
            ->get('/api/v1/products', ['Authorization' => 'Bearer ${token}', 'Content-Type' => 'application/json', 'Accept' => 'application/json'])
            ->extractJson('id', 'data[0].id') // Extract the first product ID
            ->expectStatus(200);

        // Step 4 : Api.cart.add
        $scenario->step('Api.cart.add')
            ->post('/api/v1/cart/add', [
                'product_id' => '${id}', // Use the extracted product ID
                'quantity' => 1, // Set a default quantity
            ], ['Authorization' => 'Bearer ${token}', 'Content-Type' => 'application/json', 'Accept' => 'application/json'])
            ->expectStatus(200);

        // Step 6 : Api.orders.checkout
        $scenario->step('Api.orders.checkout')
            ->post('/api/v1/orders/checkout', [
                // No Body needed for checkout
            ], ['Authorization' => 'Bearer ${token}', 'Content-Type' => 'application/json', 'Accept' => 'application/json'])
            ->expectStatus(201);
    }
}

This Volt-Test class simulates user registration, product browsing, adding to cart, and checkout using a CSV data source for user details.

You can then create a PHPUnit test that runs this Volt-Test class under load to measure its performance and can also verify data integrity:

<?php
namespace Tests\Performance;

use App\VoltTests\RegisterAndCheckout;
use VoltTest\Laravel\Testing\PerformanceTestCase;
use App\Models\Product;

class RegisterAndCheckoutTest extends PerformanceTestCase
{
    public function testPerformanceFromExistingClass(): void
    {
        // Create a product with initial quantity 100
        Product::query()->create([
            'name' => 'Test Product',
            'quantity' => 100,
        ]);
        $result = $this->runVoltTest(new EcomerceAPITest, [
            'virtual_users' => 10,
        ]);
        $this->assertVTSuccessful($result, 100);
        $this->assertVTErrorRate($result, 0);
        $this->assertVTMinResponseTime($result, 100);
        $this->assertVTAverageResponseTime($result, 200);
        $this->assertVTP95ResponseTime($result, 200);
        $this->assertVTP99ResponseTime($result, 200);
        // check the remain product in the inventory after test
        $this->assertEquals(90, Product::query()->first()->quantity, "Product quantity should be 90 after 10 registrations.");
    }
}

When you run this PHPUnit test, it will execute the RegisterAndCheckout Volt-Test class with 10 virtual users and report the performance metrics alongside your other PHPUnit tests.

./vendor/bin/phpunit --testsuite=Performance

Example Output​

The output will look like this:

 ./vendor/bin/phpunit --testsuite=Performance
PHPUnit 11.5.44 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.4.15
Configuration: path/to/app/phpunit.xml



----------------------------------------------------------------------
Performance Report: testPerformanceFromExistingClass
----------------------------------------------------------------------
Total Requests:      40
Success Rate:        100.00%
Requests/Sec (RPS):  162.91
Avg Latency:         52.854091ms
P95 Latency:         72.748667ms
P99 Latency:         78.206542ms
----------------------------------------------------------------------
.                                                                   1 / 1 (100%)

Time: 00:00.787, Memory: 28.00 MB

OK (1 test, 13 assertions)

In this PHPUnit test:

• We create a RegistrationPerformanceTest class that extends PerformanceTestCase.
• We define a test method testPerformanceFromExistingClass that runs the RegistrationTest Volt-Test class with 10 virtual users.
• We use various assertions to validate the performance metrics of the test.

This approach allows you to leverage existing Volt-Test classes while integrating them seamlessly into your PHPUnit test suite.

This tests can catch race conditions and data integrity issues under load, ensuring your application behaves correctly even during high traffic scenarios.

Integration Benefits​

By integrating Volt-Test with PHPUnit, you gain several advantages:

• Unified Testing Workflow: Manage all your tests—unit, feature, and performance—in one place.
• Automated Performance Regression Detection: Catch performance issues early in your development cycle
• Reusable Test Logic: Leverage existing Volt-Test classes in your PHPUnit tests for consistency and code reuse.
• CI/CD Integration: Seamlessly include load tests in your continuous integration pipelines.
• Comprehensive Reporting: Get detailed performance metrics alongside your regular test results.

What's Next: Volt-Test Cloud​

The PHPUnit integration is just one part of Volt-Test's vision for simplifying performance testing. In the near future, we plan to introduce Volt-Test Cloud—a hosted service that enables you to run large-scale load tests without managing infrastructure.

Conclusion​

Running load tests directly within PHPUnit using Volt-Test simplifies performance testing for Laravel applications. It allows developers to maintain a consistent testing workflow, catch performance regressions early, and ensure their applications can handle real-world traffic. By leveraging existing Volt-Test classes, you can also ensure data integrity under load, making your tests more robust and reliable.

Learn More​

• GitHub Release Notes →
• Full PHPUnit Integration Docs →
• Previous Article: Effortless Laravel Load Testing with Volt-Test PHP SDK →
• Stress Testing Laravel with the Volt-Test Web UI →

⭐ Star the repository on GitHub: volt-test/laravel-performance-testing

💬 Follow updates on X: @VoltTest

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​

You can 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, you can 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 letting the package generate 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​

You can capture values from responses and reuse them in later steps.

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, you’ll find detailed reports in:

storage/volttest/reports

🏁 Conclusion​

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

• Keep performance tests right inside your Laravel project.
• Run them with one simple Artisan command.
• Get detailed, actionable performance metrics before your users ever notice a slowdown.

No separate scripting language. No complex setup. Just Laravel, PHP, and the truth about your app’s performance.

📚 Docs: Laravel Performance Testing on GitHub
📦 Volt Test PHP SDK: php.volt-test.com

Load Testing​

Definition​

Load testing measures a system's behavior under expected user loads. It ensures that the system can handle a specified number of users or transactions simultaneously without degradation in performance.

Example​

A SaaS-based school management system is expected to support 10,000 concurrent students during exam submission. A load test simulates these 10,000 users submitting their answers within a short period to evaluate how the system handles the load. So Here You know the expected load, you are testing the system under that load.

Stress Testing​

Definition​

Stress testing evaluates a system's behavior under extreme conditions, often beyond its normal operational capacity. It helps determine the breaking point and whether the system fails gracefully.

Example​

A cloud-based e-commerce platform is expected to handle 100,000 users during peak shopping hours. A stress test increases the load gradually to 200,000 users to observe if the system crashes or recovers after failure.

Spike Testing​

Definition​

Spike testing analyzes how a system handles sudden and extreme increases in load. It helps identify whether the system scales effectively or crashes under sudden traffic spikes.

Example​

A ticket booking system for a concert sees an abrupt spike in traffic when tickets go on sale. A spike test simulates a rapid increase from 1,000 to 50,000 users within a minute to test system stability.

Endurance Testing​

Definition​

Endurance testing evaluates a system's performance over an extended period under normal expected loads. It detects memory leaks, slowdowns, and other long-term performance issues.

Example​

A banking application undergoes endurance testing by simulating 5,000 users performing transactions continuously over 24 hours to ensure there are no memory leaks or performance degradation.

Scalability Testing​

Definition​

Scalability testing assesses a system's ability to handle increased loads by adding resources. It helps determine how the system scales vertically or horizontally to accommodate more users or transactions.

Example​

A cloud-based video streaming platform scales horizontally by adding more servers to handle increased user traffic during peak hours. Or it scales vertically by upgrading server resources to improve performance. then downgrades the resources when the traffic decreases.

Volume Testing​

Definition​

Volume testing measures how the system performs with a large volume of data. It helps identify database performance issues, indexing problems, and storage limitations.

Example​

A CRM system undergoes volume testing by loading 1 million customer records to evaluate how the system handles the data volume. It checks if the system slows down, crashes, or maintains performance with the large dataset.

Latency Testing​

Definition​

Latency testing evaluates a system's response time under different network conditions. It helps identify delays in data transmission, network congestion, and server processing times.

Example​

A real-time multiplayer game undergoes latency testing to measure the time it takes for player actions to reflect on other players' screens. It simulates high latency, packet loss, and network congestion to observe how the game performs under these conditions.

Differences Between Performance Testing Types​

• Load Testing vs. Stress Testing: Load testing evaluates a system under expected loads, while stress testing pushes the system beyond its limits.
• Spike Testing vs. Endurance Testing: Spike testing simulates sudden load spikes, while endurance testing evaluates long-term performance.
• Scalability Testing vs. Volume Testing: Scalability testing assesses the system's ability to scale, while volume testing measures performance with large data volumes.
• Latency Testing: Latency testing evaluates response times under different network conditions.

Conclusion​

Performance testing is crucial for ensuring software applications meet performance expectations and deliver a seamless user experience. By understanding the different types of performance testing and their purposes, you can identify the right tests to conduct based on your application's requirements. Whether you need to evaluate expected loads, extreme conditions, scalability, or latency, performance testing helps you optimize your system for peak performance.

• 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:

1. 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.

2. 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.

3. 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.

4. 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.

5. 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.

6. 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.

7. 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.

8. 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.

9. 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

Problem​

As a PHP developer, I’ve often faced a common challenge: existing performance testing tools often require learning a new language, platform, or configuration syntax. This cognitive overhead leads many teams to defer proper load testing or rely on third-party services, creating additional costs and dependencies.

VoltTest bridges this gap by providing:

• A fluent, intuitive PHP API that feels natural to PHP developers
• The raw power of Go for generating heavy loads with minimal resources
• No additional infrastructure requirements beyond your existing PHP environment
• Comprehensive metrics to identify bottlenecks and performance issues

How VoltTest Works: PHP Interface, Go Engine​

VoltTest employs a unique dual-language architecture that delivers the best of both worlds:

1. Your PHP code defines test scenarios, configurations, and validation rules
2. The SDK transforms these definitions into a format the Go engine understands
3. The Go engine executes the actual load testing with true concurrency
4. Results are streamed back to your PHP application for analysis

This architecture allows you to write and maintain tests in familiar PHP syntax while benefiting from Go's exceptional performance characteristics for the load generation.

Key Features​

• Fluent API: Natural, chainable PHP methods for defining test scenarios
• Multi-scenario support: Test different user flows with configurable weight distribution
• Variable extraction: Capture and reuse values from responses (cookies, headers, JSON paths and HTML)
• Data-driven testing: Feed tests with CSV files to simulate realistic user data
• Detailed metrics: Get comprehensive performance insights including response times, throughput, and error rates

Getting Started with VoltTest​

Let's create a simple performance test to demonstrate VoltTest's capabilities:

<?php

use VoltTest\VoltTest;

// Create a new test
$test = new VoltTest(
    'API Performance Test',
    'Tests our REST API under load'
);

// Configure test parameters
$test
    ->setVirtualUsers(50)      // Number of concurrent users
    ->setDuration('30s')       // Test duration
    ->setRampUp('5s')          // Gradually ramp up to full load
    ->setHttpDebug(false);     // Disable HTTP debug output

// Create a test scenario
$apiScenario = $test->scenario('API Flow')
    ->setWeight(100);           // Full weight (100%) to this scenario

// Define the first step - Get auth token
$apiScenario->step('Get Token')
    ->post('https://api.example.com/auth', '{"username":"test","password":"test123"}')
    ->header('Content-Type', 'application/json')
    ->extractFromJson('token', 'data.token')  // Extract token from response
    ->validateStatus('success', 200);

// Define the second step - Use the token
$apiScenario->step('Get User Data')
    ->get('https://api.example.com/users/me')
    ->header('Authorization', 'Bearer ${token}')  // Use extracted token
    ->validateStatus('success', 200);

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

// Display results
echo "Success Rate: " . $result->getSuccessRate() . "%\n";
echo "Requests/sec: " . $result->getRequestsPerSecond() . "\n";
echo "Avg Response: " . $result->getAvgResponseTime() . "\n";
echo "P95 Response: " . $result->getP95ResponseTime() . "\n";

Advanced Features: Testing with Real-World Data​

VoltTest supports data-driven testing with CSV files, allowing you to simulate diverse user behaviors:

// users.csv contains columns: email,password,user_id
$loginScenario->setDataSourceConfiguration(
    new DataSourceConfiguration('users.csv', 'random', true)
);

// Now you can reference CSV columns in your requests
$loginScenario->step('Login')
    ->post('https://example.com/login', 
           'email=${email}&password=${password}')  // Variables from CSV
    ->validateStatus('success', 200);

Extracting and Using Dynamic Values​

One of VoltTest's most powerful features is its ability to extract and reuse values from responses:

// Extract CSRF token from HTML response
$scenario->step('Get Login Page')
    ->get('https://example.com/login')
    ->extractFromHtml('csrf_token', 'input[name="_token"]', 'value')
    ->validateStatus('success', 200);

// Use the extracted token in the next request
$scenario->step('Submit Login')
    ->post('https://example.com/login',
           '_token=${csrf_token}&email=user@example.com&password=secret')
    ->validateStatus('success', 302);  // Expecting a redirect

Understanding Your Results​

VoltTest provides comprehensive metrics to analyze performance:

$result = $test->run();

// Access detailed metrics
echo "Test duration: " . $result->getDuration() . "\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 "Median response time: " . $result->getMedianResponseTime() . "\n";
echo "P95 response time: " . $result->getP95ResponseTime() . "\n";
echo "P99 response time: " . $result->getP99ResponseTime() . "\n";

Why VoltTest Created​

As PHP developers, I’ve often found performance testing to be a challenge. Existing tools like JMeter, Gatling or Locust are powerful but require learning new syntax, languages or complex GUIs. We wanted a tool that would:

1. Feel native to PHP developers with an intuitive, fluent API
2. Handle serious load testing without requiring huge resources
3. Integrate seamlessly with PHP codebases and workflows
4. Provide comprehensive metrics with minimal configuration

VoltTest achieves this through a unique architecture that lets you write your tests in familiar PHP syntax while leveraging Go's exceptional performance capabilities for the actual load generation.

What Makes VoltTest Different?​

Unlike traditional PHP-based testing tools that struggle with concurrency limitations, VoltTest uses a high-performance Go engine that runs behind the scenes. This gives you:

• True concurrent users instead of PHP's process-based concurrency
• Minimal resource usage even when simulating thousands of users
• Accurate timing and metrics collection for detailed analysis

VoltTest brings modern stress testing to PHP with an intuitive API and high-performance Go engine. No new languages, no complex setup—just performance insights when you need them.

Conclusion​

VoltTest PHP SDK brings enterprise-grade performance testing capabilities to PHP developers with a familiar, easy-to-use API. By combining PHP's developer-friendly syntax with Go's raw performance power, VoltTest enables teams to integrate load testing directly into their development workflows without additional infrastructure or expertise.

Whether you're building APIs, websites, or complex applications, VoltTest gives you the tools to ensure your PHP applications can handle real-world traffic with confidence.

Getting Started​

💡 Ready to test your PHP app’s performance? Try Volt-Test today! 🚀

composer require volt-test/php-sdk

For more examples and detailed documentation, visit Examples Page in docs.