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

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

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: Neuerungen, Highlights und Vorbereitungstipps

PHPUnit 12, das nächste Major-Release des führenden PHP-Testing-Frameworks, steht vor der Tür und wird voraussichtlich am 7. Februar 2025 veröffentlicht. Sebastian Bergmann, der Initiator und Hauptentwickler von PHPUnit, hat in einem exklusiven Interview mit iX die wichtigsten Neuerungen, Änderungen und Vorbereitungstipps für die kommende Version vorgestellt. Dieser Abschnitt bietet einen detaillierten Überblick über die Highlights von PHPUnit 12 und zeigt, wie Sie sich optimal auf das Update vorbereiten können.

1. Klare Trennung von Test Stubs und Mock Objects

Eines der größten Highlights von PHPUnit 12 ist die strikte Trennung zwischen Test Stubs und Mock Objects. Diese Änderung zielt darauf ab, die Lesbarkeit und Verständlichkeit von Testcode zu verbessern.

In der objektorientierten Programmierung werden Test Doubles (Test-Stellvertreter) verwendet, um Abhängigkeiten zu isolieren oder die Kommunikation zwischen Objekten zu testen. Bisher bot PHPUnit eine allgemeine API (getMock()) zur Erstellung von Test Doubles an, was oft zu Verwirrung führte, da die Begriffe "Test Stub" und "Mock Object" synonym verwendet wurden.

Mit PHPUnit 12 werden nun separate APIs für die Erstellung von Test Stubs und Mock Objects eingeführt. Test Stubs werden verwendet, um Abhängigkeiten zu isolieren und spezifische Rückgabewerte zu simulieren, während Mock Objects dazu dienen, die Kommunikation zwischen Objekten zu testen und Interaktionen zu verifizieren. Diese klare Trennung führt zu besser lesbarem und wartbarem Testcode, da die Absicht hinter jedem Test eindeutig dokumentiert wird.

2. Verbesserte Code Coverage-Kontrolle

PHPUnit 12 bringt neue Funktionen zur präziseren Steuerung der Code Coverage. Mit zusätzlichen Attributen können Entwickler gezielter festlegen, welche Teile des Codes in die Coverage-Analyse einbezogen werden sollen.

Zu den neuen Attributen gehören @covers, das definiert, welche Methode oder Klasse getestet wird, und @uses, das angibt, welche zusätzlichen Klassen oder Methoden im Test verwendet werden, aber nicht direkt getestet werden sollen. Diese Verbesserungen ermöglichen eine genauere Messung der Testabdeckung, vermeiden falsch positive Coverage-Ergebnisse und bieten eine bessere Kontrolle über die Teststrategie.

3. Abwärtsinkompatible Änderungen

Wie bei jeder Hauptversion nutzt PHPUnit 12 die Gelegenheit, veraltete Funktionen zu entfernen und die Codebasis zu bereinigen. Alle Funktionen, die in PHPUnit 11 als "deprecated" markiert wurden, werden in PHPUnit 12 vollständig entfernt. Dazu gehören veraltete APIs, Konfigurationsoptionen und Methoden.

Um sich auf diese Änderungen vorzubereiten, sollten Entwickler ihre Tests mit PHPUnit 11 ausführen und überprüfen, ob Deprecation-Warnungen angezeigt werden. Anschließend sollte der Code aktualisiert werden, um veraltete Funktionen durch die neuen APIs zu ersetzen. Zudem empfiehlt es sich, die aktuelle Entwicklungsversion von PHPUnit 12 zu nutzen, um die Tests frühzeitig zu validieren.

4. Unterstützung für moderne PHP-Features

PHPUnit 12 ist vollständig kompatibel mit den neuesten PHP-Versionen, einschließlich PHP 8.3 und 8.4. Das Framework unterstützt moderne PHP-Features wie Attribute für eine bessere Integration von Metadaten in Tests, Union Types zur Typsicherheit in Testmethoden und Named Arguments für eine klarere und lesbarere Testkonfiguration.

5. Verbesserte Performance und Skalierbarkeit

PHPUnit 12 wurde unter der Haube optimiert, um die Testausführung schneller und effizienter zu gestalten. Die parallele Ausführung von Tests reduziert die Gesamtdauer der Testsuite, während verbesserte Unterstützung für Datenbank-Transaktionen die Isolation und Performance erhöht. Zudem wurden wiederverwendbare Testdaten (Fixtures) optimiert, um den Speicherverbrauch zu reduzieren.

6. Integration in CI/CD-Pipelines

PHPUnit 12 bietet verbesserte Integrationen in moderne CI/CD-Tools wie GitLab CI/CD, GitHub Actions und Jenkins. Unterstützung für verschiedene Coverage-Formate (z.B. Cobertura) ermöglicht eine nahtlose Integration in CI/CD-Pipelines, und vordefinierte Docker-Images erleichtern die Einrichtung von Testumgebungen.

7. Vorbereitung auf PHPUnit 12

Um reibungslos auf PHPUnit 12 umzusteigen, empfiehlt Sebastian Bergmann folgende Schritte:

Zunächst sollten Entwickler sicherstellen, dass ihre Tests mit PHPUnit 11 fehlerfrei laufen und keine Deprecation-Warnungen anzeigen. Anschließend kann die aktuelle Entwicklungsversion von PHPUnit 12 genutzt werden, um die Tests frühzeitig zu validieren. Die Teststrategie sollte an die neuen APIs und Best Practices angepasst werden, insbesondere im Hinblick auf die Trennung von Test Stubs und Mock Objects. Schließlich ist es wichtig, die CI/CD-Pipelines zu aktualisieren, um die neuen Features wie parallele Testausführung und verbesserte Coverage-Reports nutzen zu können.

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:

Code:

          # Alle Tests ausführen
./vendor/bin/phpunit tests
# Spezifische Tests ausführen
./vendor/bin/phpunit --filter testDivide tests
# Mit Coverage-Report
./vendor/bin/phpunit --coverage-html coverage tests

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

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.

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.

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.

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.