NCA Social Media
Erstellt:
Aktualisiert:
Autor:
Roland Golla
PHPUnit Logo

Was ist PHPUnit? Das Testing Framework für PHP

PHPUnit ist das Standard Framework für automatisierte Tests in PHP. Seit über 20 Jahren sichert es Code ab, findet Regressionen früh und macht Refactorings ohne Angst möglich. Entwickelt hat es Sebastian Bergmann, der es bis heute als Open Source Projekt pflegt.
Im Februar 2026 kam Version 13 mit Sealed Test Doubles und neuen Array Assertions. Danach folgten die Minor Releases 13.1 bis 13.3: Data Providers als Closures, präzise Test IDs, klarere Exception Erwartungen und eingebaute Werkzeuge gegen Flaky Tests. Dieser Leitfaden zeigt alles, von der Einrichtung bis zum nächsten Upgrade.
Das Framework folgt der xUnit Architektur und passt in jeden Workflow: lokal, in der CI CD Pipeline, vor jedem Deployment. Egal ob Symfony, Laravel oder Sulu CMS, ohne Tests geht 2026 wenig.
Inhalt
CYPRESS.IO Ambassador und IT Consultant für QA Engenieering und Qualität in PHP Projekten.
Erreichen Sie unsere PHP Consultant Spezialisten

Wir arbeiten seit über 20 Jahren mit PHP und Symfony. Wir helfen bei PHP Updates und PHP Refactoring und beraten remote zu allen Fragen rund um PHP. Zuerst sichern Tests und statische Analyse den Code ab, dann räumen wir auf. Automatische CI/CD Deployments und eine stabile Docker Umgebung sorgen dafür, dass jede Änderung sicher live geht.

Was ist neu in PHPUnit 13.0?

Das Release vom 6. Februar 2026 setzt PHP 8.4 voraus und bringt vier echte Verbesserungen mit:
  • Sealed Test Doubles: Mit seal() schließt du die Konfiguration eines Mocks oder Stubs ab. Danach sind keine weiteren expects() oder method() Aufrufe mehr möglich. Über eine Konfigurationsoption lassen sich versiegelte Mock Objects sogar erzwingen.
  • Neue Array Assertions: Zum Beispiel assertArraysHaveEqualValues() und assertArraysHaveEqualValuesIgnoringOrder(). Sie unterscheiden sauber zwischen striktem und losem Vergleich, mit oder ohne Keys, geordnet oder ungeordnet.
  • withConsecutive() Ersatz: Seit Version 10 eine offene Baustelle. Jetzt prüfen withParameterSetsInOrder() und withParameterSetsInAnyOrder() Parameter über mehrere Aufrufe hinweg.
  • any() ist hard deprecated: Ein Mock soll Interaktionen prüfen. Wer any() nutzt, sagt eigentlich "ist mir egal" und braucht einen Stub.
Code:
          

// Mock konfigurieren und versiegeln
$mock = $this->createMock(PaymentGateway::class);

$mock->expects($this->once())
    ->method('charge')
    ->with(99.99)
    ->willReturn(true);

// Ab hier ist die Konfiguration dicht
$mock->seal();

$processor = new OrderProcessor($mock);
$processor->processOrder($order);

So sieht der Ersatz für withConsecutive() aus. Der Mock erwartet zwei Aufrufe mit genau diesen Parametern in genau dieser Reihenfolge:
Code:
          

$dispatcher = $this->createMock(Dispatcher::class);

$dispatcher
    ->expects($this->exactly(2))
    ->method('dispatch')
    ->withParameterSetsInOrder(
        [new OrderPlaced],
        [new InvoiceSent],
    );

$service = new CheckoutService($dispatcher);
$service->checkout($cart);

Spielt die Reihenfolge keine Rolle, nimm withParameterSetsInAnyOrder(). Sebastian Bergmann rät, die feste Reihenfolge nur dann zu prüfen, wenn sie für das Verhalten wirklich zählt. Sonst bricht der Test bei jedem harmlosen Refactoring, obwohl die Funktion stimmt.

Was ist neu in PHPUnit 13.1, 13.2 und 13.3?

Die Major Version im Februar räumt auf, die neuen Features kommen danach. Die Minor Releases 13.1 bis 13.3 lösen Probleme, die fast jedes Team aus dem Alltag kennt.
PHPUnit 13.1: Closures und mehr Daten im Report
  • #[DataProviderClosure] schreibt Testdaten direkt an den Test, mit PHP 8.5
  • Das Open Test Reporting XML enthält jetzt Deprecations, Notices, unerwartete Ausgaben und Gruppen
  • Eigene Issue Trigger Resolver ordnen Deprecations richtig zu, etwa wenn ein Framework sie stellvertretend auslöst
  • Coverage Daten mit relativen Pfaden, zusammenführbar über mehrere Maschinen
PHPUnit 13.2: Präzision und klare Fehler
  • Test IDs benennen jeden Test eindeutig, auch einzelne Data Sets
  • expectExceptionMessageIs() ersetzt das missverständliche expectExceptionMessage()
  • withParameterSetsInPartialOrder() und willReturnStrictMap() für genauere Test Doubles
  • Neue Diff Engine: Diffs großer Strings brauchen Millisekunden statt Sekunden
  • Ein vorher registrierter Error Handler wird verkettet statt still ersetzt
  • Strg C zeigt die bisherigen Ergebnisse, statt hart abzubrechen
Code:
          

# Alle Tests mit ihrer ID auflisten
vendor/bin/phpunit --list-test-ids

# Genau die Tests aus einer Datei ausführen, eine ID pro Zeile
vendor/bin/phpunit --test-id-filter-file failed-tests.txt

# Mehr Kontext im Diff und kompakte Ausgabe
vendor/bin/phpunit --diff-context 10 --compact

PHPUnit 13.3: Wiederholung und Durchblick
  • --repeat und #[Repeat] führen jeden Test mehrfach hintereinander aus und decken so Flaky Tests auf
  • #[Retry] wiederholt fehlgeschlagene Tests, die sich nicht stabil machen lassen. Jeder Test, der erst im zweiten Anlauf besteht, steht verpflichtend in der Zusammenfassung
  • Der Code Coverage Report zeigt Namespaces und Klassen statt nur Dateien
  • Branch und Path Coverage werden sichtbar, inklusive Kontrollflussgraph pro Methode
  • Filter nach Small, Medium und Large zeigt, was deine Unit Tests allein abdecken
Code:
          

use PHPUnit\Framework\Attributes\Repeat;
use PHPUnit\Framework\Attributes\Retry;
use PHPUnit\Framework\Attributes\Test;

#[Test]
#[Repeat(100)]
public function cacheKeepsStateAcrossCalls(): void
{
    // läuft bis zu 100 Mal, stoppt beim ersten Fehler
}

#[Test]
#[Retry(3)]
public function fetchesRatesFromRemoteService(): void
{
    // bis zu drei Versuche, jeder auf einer frischen Instanz
}

Wiederholt werden nur Tests mit Rückgabetyp void, die nicht über #[Depends] von anderen Tests abhängen. Unsere Empfehlung: #[Repeat] zum Aufspüren nutzen, #[Retry] nur als bewusste Ausnahme für Tests gegen Dienste, deren Timing du nicht kontrollierst.

PHPUnit Installation und Einrichtung 2026

Du installierst PHPUnit über Composer als Dev Dependency. Für PHPUnit 13 brauchst du:
  • PHP 8.4 oder höher, PHP 8.5 wird ebenfalls unterstützt
  • Composer 2
  • die PHP Extensions dom, json, libxml, mbstring, xml und xmlwriter
Code:
          

composer require --dev phpunit/phpunit ^13.0

Danach gehört eine phpunit.xml in den Projekt Root. Metadaten an Tests laufen ausschließlich über PHP Attributes, die Konfiguration bleibt davon unberührt:
Code:
          

<?xml version="1.0" encoding="UTF-8"?>
<phpunit bootstrap="vendor/autoload.php"
         colors="true"
         cacheDirectory=".phpunit.cache"
         executionOrder="depends,defects">
    <testsuites>
        <testsuite name="Unit">
            <directory>tests/Unit</directory>
        </testsuite>
        <testsuite name="Integration">
            <directory>tests/Integration</directory>
        </testsuite>
    </testsuites>
    <source>
        <include>
            <directory>src</directory>
        </include>
    </source>
</phpunit>

Die Trennung in Unit und Integrationstests ermöglicht gezielte Läufe. Mit executionOrder="depends,defects" laufen Tests, die zuletzt gescheitert sind, zuerst. Seit 13.2 zählen dafür nur noch echte Errors und Failures, nicht mehr Warnungen oder übersprungene Tests. Prüfe deine Konfiguration mit --validate-configuration, bevor sie in die Pipeline geht.

Migration von PHPUnit 12 auf PHPUnit 13

Der Weg von 12 auf 13 ist klar: Erst läuft die Test Suite unter PHPUnit 12.5 ohne Deprecation Warnungen. Dann folgt das Upgrade. Die wichtigsten Breaking Changes:
  • PHP 8.4 Pflicht: Projekte auf PHP 8.3 oder älter bleiben bei PHPUnit 12
  • Entfernte Features: Alles, was in PHPUnit 12 hard deprecated war, ist raus
  • any() Matcher: hard deprecated, umstellen auf konkrete Matcher oder Test Stubs
  • Annotations: seit PHPUnit 12 entfernt, nur noch PHP Attributes
Rector nimmt dir einen Großteil der Arbeit ab. Es wandelt Annotations in Attributes um, passt veraltete API Aufrufe an und modernisiert die Test Syntax:
Code:
          

composer require --dev rector/rector
./vendor/bin/rector process tests/ --set phpunit

Nach Rector prüfst du jeden Test von Hand, vor allem komplexe Mock Setups und eigene Assertions. Arbeite in einem eigenen Branch und lass die CI CD Pipeline als Quality Gate entscheiden. Sebastian Bergmann ist dabei deutlich: Wer unter 12.5 noch Deprecation Warnungen sieht, soll gar nicht erst auf 13 wechseln.
PHPUnit 14 kommt im Februar 2027. Jedes Jahr im Februar erscheint eine neue Major Version. Sie entfernt alte Deprecations und streicht PHP Versionen ohne Support. Neue Features kommen über das Jahr in den Minor Releases. Wer das Muster kennt, macht aus dem Upgrade einen festen Termin statt eines Projekts:
  • Nach jedem Minor Release die Deprecation Liste lesen und Stück für Stück abarbeiten
  • Minor Versionen automatisch aktuell halten, bei uns übernimmt das Renovate
  • Jetzt schon umstellen, was in 13.2 deprecated wurde: expectExceptionMessage() sowie --order-by duration und --order-by size
Wer so arbeitet, ist im Februar nach wenigen Stunden fertig. Wer drei Major Versionen zurückliegt, braucht Wochen.

PHPUnit Grundlagen: Der erste Test mit Attributes

Seit PHPUnit 12 sind PHP Attributes der einzige Weg, Metadaten an Tests zu binden. Die alte Annotation Syntax mit @test oder @dataProvider funktioniert nicht mehr. Ein einfacher Unit Test in PHPUnit 13:
Code:
          

use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\Attributes\CoversClass;

#[CoversClass(Calculator::class)]
class CalculatorTest extends TestCase
{
    #[Test]
    public function addsTwoNumbers(): void
    {
        // Arrange
        $calculator = new Calculator();

        // Act
        $result = $calculator->add(2, 3);

        // Assert
        $this->assertSame(5, $result);
    }

    #[Test]
    public function divideByZeroThrowsException(): void
    {
        $this->expectException(\DivisionByZeroError::class);

        $calculator = new Calculator();
        $calculator->divide(10, 0);
    }
}

Das AAA Pattern mit Arrange, Act und Assert teilt jeden Test in drei klare Phasen. Die wichtigsten Assertions:
  • assertSame() prüft Typ und Wert strikt
  • assertEquals() prüft Wertgleichheit mit Typumwandlung
  • assertTrue() und assertFalse() für boolesche Werte
  • assertInstanceOf() für Objekttypen
  • assertCount() für die Anzahl der Elemente
  • ab 13.2 Assertions, die Strings ohne Rücksicht auf Leerzeichen vergleichen, praktisch für generiertes HTML oder Code
Best Practice: Methodennamen beschreiben das Verhalten. Statt testAdd lieber addsTwoPositiveNumbers mit dem #[Test] Attribute.

Fortgeschrittene Techniken: Mocking, Data Providers und Sealed Doubles

Data Providers machen Tests parametrisierbar. Der klassische Weg läuft über das #[DataProvider] Attribute und eine statische Methode:
Code:
          

use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Test;

#[Test]
#[DataProvider('additionProvider')]
public function addsNumbers(int $a, int $b, int $expected): void
{
    $calc = new Calculator();
    $this->assertSame($expected, $calc->add($a, $b));
}

public static function additionProvider(): array
{
    return [
        'zero plus zero' => [0, 0, 0],
        'positive numbers' => [1, 2, 3],
        'negative numbers' => [-1, -2, -3],
    ];
}

Seit PHPUnit 13.1 geht es auch ohne String Verweis auf eine zweite Methode. Mit #[DataProviderClosure] stehen die Testdaten direkt am Test. Voraussetzung ist PHP 8.5, weil erst diese Version Closures in konstanten Ausdrücken erlaubt. Die Closure muss statisch sein:
Code:
          

use PHPUnit\Framework\Attributes\DataProviderClosure;
use PHPUnit\Framework\Attributes\Test;

#[Test]
#[DataProviderClosure(
    static function (): array
    {
        return [
            'zero plus zero' => [0, 0, 0],
            'positive numbers' => [1, 2, 3],
        ];
    }
)]
public function addsNumbers(int $a, int $b, int $expected): void
{
    $this->assertSame($expected, (new Calculator())->add($a, $b));
}

Die Trennung zwischen Test Stubs und Mock Objects ist seit PHPUnit 12 verbindlich. PHPUnit 13 schärft sie mit Sealed Test Doubles nach:
  • createStub() isoliert Abhängigkeiten und liefert Rückgabewerte
  • createMock() prüft die Kommunikation zwischen Objekten
  • seal() schließt die Konfiguration ab
  • ab 13.2 willReturnStrictMap() für strikten Vergleich beim Mapping von Argumenten auf Rückgabewerte
Code:
          

#[Test]
public function sendsNotificationOnOrderCompletion(): void
{
    // Stub: liefert die Bestellung
    $repository = $this->createStub(OrderRepository::class);
    $repository->method('findById')
        ->willReturn(new Order(id: 42, total: 99.99));

    // Mock: prüft, dass die Benachrichtigung rausgeht
    $notifier = $this->createMock(NotificationService::class);
    $notifier->expects($this->once())
        ->method('send')
        ->with($this->stringContains('Bestellung #42'));

    // Versiegelt: keine weiteren Erwartungen mehr möglich
    $notifier->seal();

    $service = new OrderService($repository, $notifier);
    $service->completeOrder(42);
}

Beim Exception Testing hat sich in 13.2 etwas Wichtiges geändert. expectExceptionMessage() war schon immer missverständlich benannt: Es prüfte nie auf Gleichheit, nur ob die Nachricht den Text enthält. Die Methode ist jetzt deprecated. Stattdessen gibt es drei klare Varianten:
  • expectExceptionMessageIs() verlangt eine exakte Übereinstimmung
  • expectExceptionMessageIsOrContains() behält das alte Verhalten mit Teilstring
  • expectExceptionMessageMatches() prüft gegen einen regulären Ausdruck
Code:
          

#[Test]
public function rejectsInvalidEmail(): void
{
    $this->expectException(\InvalidArgumentException::class);
    $this->expectExceptionMessageIs('Ungültige Mail Adresse');

    new EmailAddress('keine-mail');
}

PHPUnit in CI CD Pipelines integrieren

Tests entfalten ihren Wert erst in einer CI CD Pipeline. Wir nutzen GitLab CI und GitHub Actions täglich, PHPUnit läuft in beiden ohne Umwege. Zwei Konfigurationen aus der Praxis:
GitLab CI
Code:
          

phpunit:
  stage: test
  image: php:8.4-cli
  before_script:
    - apt-get update && apt-get install -y git unzip libzip-dev
    - docker-php-ext-install zip
    - curl -sS https://getcomposer.org/installer | php
    - php composer.phar install --no-interaction
  script:
    - vendor/bin/phpunit --coverage-text --colors=never
  artifacts:
    reports:
      coverage_report:
        coverage_format: cobertura
        path: coverage.xml

GitHub Actions
Code:
          

name: PHPUnit Tests
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        php: ['8.4', '8.5']
    steps:
      - uses: actions/checkout@v4
      - uses: shivammathur/setup-php@v2
        with:
          php-version: ${{ matrix.php }}
          coverage: xdebug
      - run: composer install --no-interaction
      - run: vendor/bin/phpunit --coverage-clover coverage.xml

Was PHPUnit 13 für große Suites im CI mitbringt:
  • Test IDs ab 13.2: --list-test-ids listet jeden Test eindeutig, --test-id-filter-file führt genau die Tests aus einer Datei aus. Ideal, um nur die gescheiterten Tests erneut zu starten oder eine Suite auf mehrere Worker zu verteilen.
  • Coverage zusammenführen ab 13.1: Coverage Daten nutzen relative Pfade, phpcov führt Ergebnisse paralleler Jobs zusammen.
  • Open Test Reporting ab 13.1: Das OTR XML enthält jetzt auch Deprecations, unerwartete Ausgaben und Gruppen. Mit otr-report wird daraus ein lesbarer Report.
  • Kompakte Ausgabe ab 13.2 über --compact und schnellere Diffs bei großen Strings und Arrays.
  • Parallele Läufe über Paratest
Tests sind die erste Stufe. Danach folgen statische Analyse mit PHPStan und Psalm, Patch Coverage als Merge Gate und ein Deployment, das nur grüne Branches nach vorne lässt. Wie diese Kette in echten Symfony Projekten läuft, steht in unserer CI CD Pipeline mit Docker, Staging und Preview URLs.

PHPUnit Versionen und Support-Zeiträume

PHPUnit Version PHP-Anforderung Bugfix-Support bis
PHPUnit 13 (aktuell) PHP 8.4+ Februar 2028
PHPUnit 12 PHP 8.3+ Februar 2027
PHPUnit 11 PHP 8.2+ Eingestellt (seit 02/2026)
PHPUnit 10 und älter PHP 8.1+ Eingestellt

Upgrading PHPUnit should be boring

Sebastian Bergmann, Creator und Maintainer von PHPUnit – phpunit.expert

Aus der NCA Praxis: Tests als Fundament

PHPUnit läuft bei uns in jedem PHP Projekt, zusammen mit PHPStan, Psalm und Rector. Version 13 räumt auf: Versiegelte Test Doubles fangen Fehler ab, die vorher still durchliefen. Die Minor Releases bis 13.3 machen Exceptions, Data Providers und die Arbeit mit Flaky Tests deutlich klarer.
In Legacy Projekten starten wir mit Characterization Tests, die das heutige Verhalten festhalten. Darauf bauen Integrationstests mit dem Symfony KernelTestCase und Functional Tests auf. Ob die Tests wirklich etwas prüfen, zeigt Mutation Testing mit Infection, wie viel sie abdecken, die Code Coverage. Im Browser übernimmt Cypress, wie wir dort mit Flaky Tests umgehen, steht im Cypress Glossar.
Wer noch auf Version 11 oder älter sitzt, geht den Weg über PHPUnit 12.5 als Zwischenschritt. Rector nimmt den Großteil der Arbeit ab. Wir schätzen den Aufwand im kostenlosen Kennenlernen und rechnen danach transparent minutengenau ab.

Häufige Fragen zu PHPUnit

Von der Einrichtung über Sealed Test Doubles bis zu Repeat und Retry: Hier findest du Antworten auf die häufigsten Fragen rund um das Testing Framework.
Was ist PHPUnit und wofür wird es 2026 eingesetzt?

PHPUnit ist das Standard Testing Framework für PHP, entwickelt von Sebastian Bergmann. Es führt automatisierte Unit, Integrations und Funktionstests aus. 2026 ist Version 13 das zentrale Werkzeug für Qualitätssicherung in PHP Projekten, von Symfony über Laravel bis Sulu CMS, lokal genauso wie in der CI CD Pipeline.

Welche PHP Version braucht PHPUnit 13 im Jahr 2026?

PHPUnit 13 braucht mindestens PHP 8.4, PHP 8.5 wird ebenfalls unterstützt. Ältere PHP Versionen bleiben bei PHPUnit 12 mit PHP 8.3 oder PHPUnit 11 mit PHP 8.2. Einzelne Features wie das DataProviderClosure Attribute aus 13.1 setzen PHP 8.5 voraus, weil erst dort Closures in konstanten Ausdrücken erlaubt sind.

Was sind die wichtigsten Neuerungen von PHPUnit 13 im Jahr 2026?

Version 13.0 brachte Sealed Test Doubles, neue Array Assertions und den Ersatz für withConsecutive. In 13.1 kamen Data Providers als Closures und reichere OTR Reports. 13.2 brachte Test IDs und neue Exception Methoden. 13.3 bringt Repeat und Retry gegen Flaky Tests sowie eine Klassenansicht im Coverage Report.

Wie migriere ich 2026 von PHPUnit 12 auf PHPUnit 13?

Lass die Test Suite zuerst unter PHPUnit 12.5 ohne Deprecation Warnungen laufen. Dann übernimmt Rector mit dem PHPUnit Set einen Großteil der Umstellung, danach folgt das Upgrade auf 13. Prüf anschließend vor allem Mock Setups und eigene Assertions von Hand und lass die CI Pipeline als Quality Gate entscheiden.

Wann erscheint PHPUnit 14 und wie bereite ich mich 2026 vor?

PHPUnit 14 ist für Februar 2027 angekündigt, denn jede Major Version erscheint im Februar. Vorbereiten heißt: nach jedem Minor Release die Deprecations lesen und Stück für Stück abarbeiten. Stell jetzt schon expectExceptionMessage und die Optionen order by duration und size um. Dann ist das Upgrade ein kurzer Schritt.

Was ist der Unterschied zwischen Test Stubs und Mock Objects?

Ein Test Stub ersetzt eine Abhängigkeit und liefert vordefinierte Rückgabewerte, erstellt mit createStub. Ein Mock Object prüft zusätzlich, ob bestimmte Methoden mit bestimmten Parametern aufgerufen werden, erstellt mit createMock. Brauchst du keine Prüfung der Aufrufe, ist ein Stub die richtige Wahl. PHPUnit weist seit 12.5 aktiv darauf hin.

Was sind Sealed Test Doubles in PHPUnit 13?

Ein Test Double wird mit seal abgeschlossen, sobald seine Konfiguration fertig ist. Danach sind keine weiteren Aufrufe von expects oder method mehr möglich. So ist der Mock vollständig eingerichtet, bevor der getestete Code läuft. Über eine Konfigurationsoption kannst du versiegelte Mock Objects in der ganzen Suite verlangen.

Was ersetzt withConsecutive in PHPUnit 13?

Zwei neue Regeln: withParameterSetsInOrder prüft Parameter über mehrere Aufrufe in fester Reihenfolge, withParameterSetsInAnyOrder in beliebiger Reihenfolge. Seit 13.2 gibt es withParameterSetsInPartialOrder für den Mittelweg. Damit fallen die langen Callback Konstruktionen weg, die viele Teams seit PHPUnit 10 als Ersatz gebaut hatten.

Wie funktionieren Data Providers in PHPUnit 13?

Klassisch verweist das DataProvider Attribute auf eine statische Methode, die ein Array liefert. Seit 13.1 kannst du mit DataProviderClosure die Daten als statische Closure direkt an den Test schreiben, Voraussetzung ist PHP 8.5. Benannte Keys machen die Ausgabe in beiden Varianten deutlich lesbarer.

Warum ist expectExceptionMessage in PHPUnit 13 deprecated?

Der Name führte in die Irre. Die Methode prüfte nie auf Gleichheit, sondern nur, ob die Nachricht den Text enthält. Seit 13.2 gibt es expectExceptionMessageIs für exakte Treffer, expectExceptionMessageIsOrContains für das alte Verhalten und weiterhin expectExceptionMessageMatches für reguläre Ausdrücke. Stell bestehende Tests am besten jetzt um.

Wie hilft PHPUnit 13.3 gegen Flaky Tests?

Mit der Option repeat und dem Repeat Attribute läuft jeder Test bis zu einer festen Anzahl hintereinander, so zeigen sich wackelnde Tests. Das Retry Attribute wiederholt einen fehlgeschlagenen Test, wenn sich Flakiness nicht beheben lässt. Jeder Test, der erst nach Fehlversuchen besteht, erscheint verpflichtend in der Zusammenfassung des Laufs.

Wie integriere ich PHPUnit in eine CI CD Pipeline?

PHPUnit läuft in jeder CI Plattform. Für GitLab CI und GitHub Actions reicht ein PHP Image mit Composer und der Befehl vendor/bin/phpunit. Coverage Reports exportierst du als Artefakt. Bei großen Suites helfen Test IDs zum Verteilen auf Worker und phpcov zum Zusammenführen der Coverage.

Was kostet professionelle Unterstützung bei der PHPUnit Migration?

Das hängt von Größe und Zustand der Test Suite ab. Never Code Alone startet mit einem kostenlosen Kennenlernen, schätzt dann den Aufwand und rechnet transparent minutengenau ab. Es gibt keine Pakete und keine Mindestlaufzeit. Oft reicht eine Begleitung beim Rector Setup und bei den schwierigen Mock Fällen.

Welche PHPUnit Version sollte ich für neue Projekte verwenden?

Für neue Projekte nimmst du PHPUnit 13 mit PHP 8.4 oder 8.5. Diese Kombination hat laut Support Plan den längsten Bugfix Zeitraum und alle aktuellen Features wie Sealed Test Doubles, Test IDs und Repeat. Halte die Minor Versionen automatisch aktuell, dann bleibt auch der Sprung auf PHPUnit 14 klein.