"PHP Unit" Schriftzug. PHP in hellblau und das Wort "Unit" in dunkelblau

PHPUnit Tutorial: Der ultimative Leitfaden für PHP Test Automation 2025

PHPUnit ist das führende Testing-Framework für PHP und ein unverzichtbares Werkzeug für professionelle Entwicklung. In zahlreichen Enterprise-Projekten hat sich PHPUnit als Grundpfeiler der Qualitätssicherung bewährt, besonders in automatisierten CI/CD Pipelines.

Dieser Leitfaden bietet einen strukturierten Einstieg in PHPUnit - von den ersten Schritten bis hin zu fortgeschrittenen Testing-Strategien.

PHPUnit 12 – Quick Reference

Released 02/2025 | Aktuell: 12.5 | Erfordert PHP 8.3+

Annotations → Attributes (Breaking!)

Code:

          // ❌ Entfernt
/** @test @dataProvider data @covers \App\Calc */

// ✅ PHPUnit 12
#[Test]
#[DataProvider('data')]
#[CoversClass(Calc::class)]

Annotations und Attributes können nicht gemischt werden – komplette Migration erforderlich.

Stubs vs. Mocks

Code:

          $stub = $this->createStub(Repo::class);    // Isoliert Abhängigkeiten
$mock = $this->createMock(Mailer::class);  // Verifiziert Kommunikation

Klare Trennung macht Tests lesbarer und Absichten deutlicher.

Migration mit Rector

Code:

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

Warum jetzt updaten?

PHPUnit 10 erhält keine Bug-Fixes mehr
PHP 8.3/8.4 Kompatibilität gesichert
Attributes sind typsicher und IDE-freundlich
Saubere Test-Architektur durch Stub/Mock-Trennung

Support-Zeiträume

PHPUnit 12 → bis 02/2027
PHPUnit 11 → bis 02/2026
PHPUnit 10 → ❌ eingestellt

Unterstützung beim Update?

Wir helfen bei der Migration eurer Test-Suite auf PHPUnit 12 – von der Rector-Konfiguration bis zur CI/CD-Integration. Jetzt Kontakt aufnehmen →

Installation und Einrichtung

Systemvoraussetzungen

PHP 7.4 oder höher
Composer
Git (empfohlen)

Installation via Composer

Code:

          composer require --dev phpunit/phpunit ^10.0

Basis-Konfiguration

Die phpunit.xml im Root-Verzeichnis des Projekts:

Code:

          <?xml version="1.0" encoding="UTF-8"?>
<phpunit bootstrap="vendor/autoload.php"
        colors="true"
        verbose="true"
        stopOnFailure="false">
   <testsuites>
       <testsuite name="Test Suite">
           <directory>tests</directory>
       </testsuite>
   </testsuites>
</phpunit>

Grundlagen des Unit Testing

Erste Schritte
Ein einfacher PHPUnit Test:

Code:

          use PHPUnit\Framework\TestCase;
class SimpleTest extends TestCase
{
   public function testDivide()
   {
       $simple = new Simple(10);
       $this->assertEquals(5, $simple->divide(2));
   }
}

Wichtige Assertions
PHPUnit bietet verschiedene Methoden zur Überprüfung von Erwartungen:

Code:

          // Gleichheit prüfen
$this->assertEquals($expected, $actual);
// Strikte Typprüfung
$this->assertSame($expected, $actual);
// Wahrheitswerte prüfen
$this->assertTrue($condition);
$this->assertFalse($condition);
// Null-Prüfung
$this->assertNull($variable);
// Objekttyp prüfen
$this->assertInstanceOf($expected, $actual);

Tests ausführen
Grundlegende Kommandos:

CYPRESS.IO Ambassador und IT Consultant für QA Engenieering und Qualität in PHP Projekten.

Erreichen Sie unsere PHP Consultant Spezialisten

Wir sind Experten für PHP und helfen Ihnen, Ihre digitalen Herausforderungen zu meistern. Unser erfahrenes Team unterstützt Sie bei PHP Updates, PHP Refactoring und berät Sie remote zu allen Fragen rund um PHP. Mit unseren vollautomatischen CI/CD Deployments und einer robusten Docker-Infrastruktur bringen wir Ihre PHP-Projekte auf das nächste Level. Vertrauen Sie auf unsere Expertise für zuverlässige und skalierbare PHP-Lösungen.

Demo Team Workshop Anrufen

Fortgeschrittene Techniken

Data Providers
Tests mit verschiedenen Datensätzen ausführen:

Code:

          /**
* @dataProvider additionProvider
*/
public function testAdd($a, $b, $expected)
{
   $this->assertEquals($expected, $a + $b);
}
public function additionProvider()
{
   return [
       [0, 0, 0],
       [1, 1, 2],
       [1, 2, 3]
   ];
}

Mocking
Abhängigkeiten simulieren:

Code:

          public function testUserService()
{
   $mock = $this->createMock(Database::class);
   $mock->method('query')
        ->willReturn(['id' => 1, 'name' => 'John']);
   $service = new UserService($mock);
   $user = $service->getUserById(1);
   $this->assertEquals('John', $user->getName());
}

Exception Testing
Prüfen von erwartetem Fehlverhalten:

Code:

          public function testDivideByZero()
{
   $this->expectException(InvalidArgumentException::class);
   $simple = new Simple(10);
   $simple->divide(0);
}

Integration in CI/CD-Pipelines

GitLab CI/CD Konfiguration

Code:

          phpunit:
 stage: test
 script:
   - composer install --no-interaction --no-progress
   - vendor/bin/phpunit --coverage-text --colors=never
 artifacts:
   reports:
     coverage_report:
       coverage_format: cobertura
       path: coverage.xml

Docker Integration

Code:

          FROM php:8.1-cli
RUN apt-get update && apt-get install -y \
   git \
   unzip
RUN docker-php-ext-install pdo pdo_mysql
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
WORKDIR /app

Coding Standards

Klare und aussagekräftige Benennungen:
Testmethoden sollten aussagekräftige Namen haben, die den Zweck des Tests klar beschreiben. Ein guter Testname gibt Aufschluss darüber, was getestet wird und unter welchen Bedingungen. Beispiel:

testDivideByZeroThrowsException – Der Test überprüft, ob eine Division durch Null eine Ausnahme auslöst.

testUserCreationWithValidData – Der Test validiert die Erstellung eines Benutzers mit gültigen Daten.

AAA-Pattern (Arrange, Act, Assert):
Das AAA-Pattern ist ein bewährtes Strukturierungsprinzip für Unit-Tests. Es unterteilt jeden Test in drei klar definierte Abschnitte:

Arrange: Hier werden alle notwendigen Voraussetzungen für den Test geschaffen, z. B. das Initialisieren von Objekten oder das Setzen von Testdaten.

Act: In diesem Abschnitt wird die zu testende Methode oder Funktion ausgeführt.

Assert: Hier wird überprüft, ob das Ergebnis den Erwartungen entspricht.

Beispiel:

Code:

          public function testAddTwoNumbers()
{
   // Arrange
   $calculator = new Calculator();
   
   // Act
   $result = $calculator->add(2, 3);
   
   // Assert
   $this->assertEquals(5, $result);
}

Diese Struktur sorgt für klaren und gut lesbaren Testcode.

Isolation der Tests:
Jeder Test sollte unabhängig von anderen Tests sein. Das bedeutet, dass ein Test nicht auf den Zustand angewiesen sein sollte, der durch einen vorherigen Test verändert wurde. Um dies zu gewährleisten, sollten Sie:

Keine globalen Variablen oder Zustände verwenden.

Testdaten vor jedem Test neu initialisieren.

Datenbank-Transaktionen oder Fixtures nutzen, um den Zustand nach jedem Test zurückzusetzen.

Performance-Optimierung

Parallele Ausführung nutzen:
PHPUnit unterstützt die parallele Ausführung von Tests, was die Gesamtdauer der Testsuite erheblich reduzieren kann. Dies ist besonders nützlich in großen Projekten mit Hunderten oder Tausenden von Tests. Um die parallele Ausführung zu aktivieren, können Sie die --parallel-Option verwenden:

Code:

          ./vendor/bin/phpunit --parallel 4

Hierbei wird die Testsuite in vier parallele Prozesse aufgeteilt.

Fixtures für wiederverwendbare Testdaten:
Fixtures sind vordefinierte Testdaten, die in mehreren Tests wiederverwendet werden können. Sie helfen dabei, redundanten Code zu vermeiden und die Testsuite effizienter zu gestalten. PHPUnit bietet spezielle Methoden wie setUp() und tearDown(), um Fixtures zu initialisieren und zu bereinigen.

Beispiel:

Code:

          protected function setUp(): void
{
   $this->user = new User('John', 'Doe');
}
public function testUserFullName()
{
   $this->assertEquals('John Doe', $this->user->getFullName());
}

Database Transactions für Datenbank-Tests:
Datenbank-Tests können langsam und fehleranfällig sein, wenn der Zustand der Datenbank zwischen den Tests nicht korrekt zurückgesetzt wird. PHPUnit bietet Unterstützung für Datenbank-Transaktionen, um dieses Problem zu lösen. Durch die Verwendung von Transaktionen können Sie Änderungen an der Datenbank nach jedem Test rückgängig machen, ohne die Datenbank neu aufbauen zu müssen.

Beispiel:

Code:

          protected function setUp(): void
{
   $this->db = new PDO('sqlite::memory:');
   $this->db->beginTransaction();
}
protected function tearDown(): void
{
   $this->db->rollBack();
}

Diese Methode sorgt dafür, dass jeder Test in einer sauberen Umgebung ausgeführt wird.

Weitere Tipps für PHPUnit

Testabdeckung (Code Coverage) überwachen:
Nutzen Sie PHPUnit’s Code Coverage-Funktionen, um sicherzustellen, dass Ihr Code ausreichend getestet ist. Ein guter Richtwert ist eine Abdeckung von mindestens 80 %, wobei kritische Teile des Codes (z. B. Geschäftslogik) eine Abdeckung von 100 % anstreben sollten.

Mocking für Abhängigkeiten:
Verwenden Sie Mock-Objekte, um externe Abhängigkeiten wie Datenbanken oder APIs zu simulieren. Dies macht Tests schneller und zuverlässiger, da sie nicht von externen Systemen abhängig sind.

Regelmäßige Wartung der Testsuite:
Überprüfen Sie Ihre Testsuite regelmäßig auf veraltete oder redundante Tests. Eine gut gepflegte Testsuite ist effizienter und einfacher zu warten.

Häufig gestellte Fragen FAQ

Was ist PHPUnit?

PHPUnit ist das meistgenutzte Testing-Framework für PHP, das automatisierte Tests ermöglicht und die Code-Qualität sicherstellt.

Wie installiere ich PHPUnit?

Die Installation erfolgt mit einem einzigen Composer-Befehl: composer require --dev phpunit / phpunit.

Funktioniert PHPUnit mit PHP 8?

Ja, PHPUnit ist vollständig kompatibel mit PHP 8 und unterstützt alle modernen PHP-Funktionen.

Wie starte ich meinen ersten Test?

Erstellen Sie eine Test-Klasse, die von TestCase erbt, und führen Sie sie mit dem Befehl . / vendor / bin / phpunit aus.

Was ist ein Unit Test?

Ein Unit Test prüft eine einzelne Funktionseinheit des Codes auf korrektes Verhalten und isoliert sie von anderen Abhängigkeiten.

Brauche ich PHPUnit für kleine Projekte?

Auch kleine Projekte profitieren von PHPUnit, da es hilft, Fehler früh zu erkennen und die Wartbarkeit zu verbessern.

Wie teste ich Datenbank-Zugriffe?

PHPUnit bietet spezielle TestCase-Klassen für Datenbank-Tests und ermöglicht das Mocken von Datenbankverbindungen.

Was ist der Unterschied zwischen assertEquals und assertSame?

assertEquals prüft auf Wertgleichheit, während assertSame zusätzlich auf exakte Typ-Übereinstimmung testet.

Kann ich PHPUnit in meiner IDE nutzen?

Ja, alle gängigen PHP-IDEs wie PHPStorm, VS Code und Netbeans bieten integrierte Unterstützung für PHPUnit.

Wie lange dauert das Erlernen von PHPUnit?

Die Grundlagen von PHPUnit können innerhalb weniger Stunden erlernt werden, die Entwicklung guter Teststrategien erfordert jedoch Praxis.

Fazit

PHPUnit ist ein mächtiges Werkzeug für qualitativ hochwertige PHP-Entwicklung. Die systematische Implementierung von Tests verbessert die Code-Qualität, reduziert Fehler und erleichtert Refactoring-Maßnahmen erheblich.

PHPUnit 12 setzt neue Maßstäbe in Sachen Code-Qualität, Performance und Benutzerfreundlichkeit. Mit der klaren Trennung von Test Stubs und Mock Objects, verbesserten Code Coverage-Funktionen und der Unterstützung moderner PHP-Features ist PHPUnit 12 das ideale Werkzeug für professionelle PHP-Entwicklung.

Weiterführende Ressourcen

Offizielle Dokumentation & Quellen

PHPUnit Offizielle Dokumentation
phpunit.de/documentation.html
Umfassende Anleitung zur Nutzung und Konfiguration von PHPUnit.

PHPUnit GitHub Repository
github.com/sebastianbergmann/phpunit
Quellcode, Releases und Community-Support.

PHPUnit Installation und Nutzung
docs.phpunit.de/en/10.5/writing-tests-for-phpunit.html
Schritt-für-Schritt-Anleitung zum Schreiben von Tests.

Weitere PHP Refactoring Tools: Test-Frameworks

BackstopJS

Entdecken Sie, wie BackstopJS visuelle Regressionstests automatisiert und Ihre Webanwendungen vor unerwünschten Änderungen schützt.

Infection Framework

Entdecke, wie du mit dem PHP Infection Framework die Qualität deiner PHPUnit Tests verbesserst. Unser umfassender Leitfaden erklärt dir Schritt für Schritt, wie du es effektiv einsetzt, um Lücken in deiner Testabdeckung zu finden.

PHP Architecture Tester (phpat)

Erfahren Sie, wie PHP Architecture Tester (phpat) Ihre PHP-Projekte durch Architekturtests, Refactoring und die Analyse von Legacy Code verbessert. Nutzen Sie unsere Expertise bei der Integration und Automatisierung in CI/CD-Pipelines.

PHP Arkitect

Erfahren Sie, wie PHP Arkitect durch Architekturkonformität PHP Refactoring, Updates und die Pflege von Legacy Code unterstützt. Entdecken Sie den Mehrwert für Ihre Projekte und wie unsere Agentur das Tool in CI/CD-Pipelines integriert, um die Codequalität zu verbessern.