PHPUnit

Visit Website

Introduction

PHPUnit is a programmer-oriented testing framework for PHP and, as its README says, an instance of the xUnit architecture for unit testing frameworks. Created and maintained by Sebastian Bergmann, it has been the foundation of PHP testing for two decades; frameworks such as Laravel and Symfony build their testing tools on top of it, and Pest runs on PHPUnit under the hood.

PHPUnit is distributed as a PHP Archive (PHAR) with all dependencies bundled, or through Composer. It follows a predictable release cycle with a new major version each February, and each major supports the PHP versions current at the time. Version 13.4.6 was released on 2 November 2026.

Modern PHPUnit uses PHP 8 attributes such as #[Test], #[DataProvider], #[CoversClass] and #[Group], replacing older docblock annotations, which were deprecated and then removed in recent majors. The XML configuration file (phpunit.xml) defines test suites, source directories for coverage, PHP settings and extensions.

How it compares: Pest offers a more expressive, closure-based syntax and nicer output while still running on PHPUnit, so the choice is mostly about style. Codeception adds acceptance and functional testing layers, and Behat covers BDD with Gherkin. For mutation testing, Infection works on top of PHPUnit or Pest test suites, and ParaTest runs PHPUnit tests in parallel.

In the quality loop, PHPUnit handles unit and integration testing for PHP applications and libraries, with code coverage via Xdebug or PCOV feeding coverage gates and mutation testing.

The source code is at sebastianbergmann/phpunit on GitHub under the BSD-3-Clause licence, with about 20,100 stars; the most recent commit was on 11 November 2026.

Test isolation options are another useful detail. By default all tests run in one PHP process, which is fast, but #[RunInSeparateProcess] or the processIsolation setting run tests in fresh processes when global state or static caches cannot be reset. PHPUnit also detects risky tests, such as tests without assertions or tests that produce unexpected output, and can be configured to fail on deprecations, notices and warnings, which helps teams prepare for new PHP versions. The TestDox output turns test method names into readable sentences, a lightweight way to document behaviour straight from the suite.

Features

1. Assertions: A large set of assertions such as assertSame, assertEquals, assertCount, assertJsonStringEqualsJsonString and exception expectations.
2. Attributes: PHP 8 attributes for tests, data providers, groups, dependencies and coverage metadata.
3. Data providers: Feed many data sets into one test method, with named data sets for readable failures.
4. Test doubles: Built-in stubs and mock objects via createStub and createMock.
5. Code coverage: Line, branch and path coverage with Xdebug or PCOV, exported to HTML, Clover, Cobertura and more.
6. Configuration: phpunit.xml defines suites, source directories, bootstrap files and settings.
7. Events and extensions: A modern event system lets extensions hook into the test run.
8. Reporting: JUnit XML, TeamCity and TestDox output for CI and readable documentation.

Pros

1. Foundation of PHP testing: Laravel, Symfony and Pest all build on it.
2. Strict by choice: Risky-test detection and fail-on-deprecation settings help teams keep suites clean and prepare for new PHP releases.
3. Predictable releases: Clear yearly major release cycle and documented support periods.
4. Free to use: Open source under the BSD-3-Clause licence, so the core tool costs nothing to use.
5. Actively maintained: The repository had commits as recent as 11 November 2026.
6. Community: About 20,100 GitHub stars.

Cons

1. Breaking majors: Each yearly major removes deprecated features, so upgrades need attention.
2. Verbose syntax: Class-based tests are more verbose than Pest’s closures.
3. Coverage needs an extension: Xdebug or PCOV must be installed for coverage.
4. Built-in mocks are basic: Many teams prefer Mockery or Prophecy for complex doubles.

Usage and Links (Example)

Install with Composer and write a test:

composer require --dev phpunit/phpunit

<?php
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\TestCase;

final class PriceTest extends TestCase
{
    public static function discounts(): array
    {
        return ['no discount' => [100, 0, 100], 'ten percent' => [100, 10, 90]];
    }

    #[Test]
    #[DataProvider('discounts')]
    public function appliesDiscount(int $price, int $pct, int $expected): void
    {
        $this->assertSame($expected, Price::apply($price, $pct));
    }
}

Run tests with coverage (PCOV or Xdebug installed):

vendor/bin/phpunit --coverage-html coverage/

Practical tips:

1. Pin the PHPUnit major in Composer and read the release announcement before upgrading.
2. Declare a <source> element in phpunit.xml so coverage covers the right directories.
3. Add ParaTest for parallel runs and Infection for mutation testing once the suite is stable.

Resources:

• PHPUnit website
• GitHub repository
• Documentation

Pricing

PHPUnit is free and open source under the BSD-3-Clause licence.

Recommended for?

1. PHP developers writing unit and integration tests.
2. Laravel and Symfony teams, whose testing tools sit on PHPUnit.
3. Library authors needing a stable, standard test framework.
4. Teams adopting mutation testing, since Infection builds directly on PHPUnit suites.
5. Not a fit if your team prefers a more expressive syntax; Pest offers that on the same engine.

Conclusion

PHPUnit is the cornerstone of PHP testing: mature, well documented and the engine behind most PHP testing tools.

Keep up with its yearly majors, add coverage and mutation testing, and it will serve PHP projects of any size.