So verwenden Sie PHPUnit für PHP-Unit-Tests

Mit der Entwicklung der Softwareentwicklungsbranche sind Tests nach und nach zu einem unverzichtbaren Bestandteil geworden. Als grundlegendster Teil des Softwaretests kann Unit-Test nicht nur die Codequalität verbessern, sondern auch die Entwicklung und Wartung von Code durch Entwickler beschleunigen. Im PHP-Bereich ist PHPUnit ein sehr beliebtes Unit-Testing-Framework, das verschiedene Funktionen bereitstellt, die uns beim Schreiben hochwertiger Testfälle helfen. In diesem Artikel erfahren Sie, wie Sie PHPUnit für PHP-Unit-Tests verwenden.

1. PHPUnit installieren

Bevor wir PHPUnit verwenden, müssen wir es zuerst installieren. PHPUnit ist eine PHP-Bibliothek, die mit Composer installiert werden kann. Führen Sie im Stammverzeichnis Ihres Projekts den folgenden Befehl aus:

composer require --dev phpunit/phpunit

Dadurch wird PHPUnit als Entwicklungsabhängigkeit zu Ihrem Projekt hinzugefügt.

2. Testfälle schreiben

Das Schreiben von Testfällen ist normalerweise der erste Schritt, wenn wir PHPUnit verwenden. Ein Testfall ist ein Skript, das eine oder mehrere Funktionen oder Methoden testet. Angenommen, wir haben eine Calculator-Klasse:

class Calculator {
    public function add($a, $b) {
        return $a + $b;
    }
}

Wir können einen Testfall verwenden, um die Add-Methode in der Calculator-Klasse zu testen:

use PHPUnitFrameworkTestCase;

class CalculatorTest extends TestCase {
    public function testAdd() {
        $calculator = new Calculator();
        $result = $calculator->add(2, 3);
        $this->assertEquals(5, $result);
    }
}

In diesem Testfall erstellen wir eine Testklasse namens CalculatorTest, die die PHPUnitFrameworkTestCase-Klasse erbt. Wir haben auch eine Testmethode namens testAdd geschrieben, in der wir eine Calculator-Instanz erstellt und die Add-Methode ausgeführt haben und schließlich mit $this->assertEquals getestet haben, ob das von der Add-Methode zurückgegebene Ergebnis mit dem erwarteten Wert übereinstimmt.

3. Testfälle ausführen

Sobald wir die Testfälle geschrieben haben, können wir sie mit PHPUnit ausführen. Führen Sie im Stammverzeichnis unseres Projekts den folgenden Befehl aus:

vendor/bin/phpunit

Dadurch wird PHPUnit ausgeführt und alle verfügbaren Testfälle ausgeführt. Wenn Sie nur eine bestimmte Testklasse oder Testmethode ausführen möchten, können Sie den folgenden Befehl verwenden:

vendor/bin/phpunit tests/CalculatorTest.php
vendor/bin/phpunit --filter testAdd tests/CalculatorTest.php

4. Behauptungen verwenden

PHPUnit bietet eine Vielzahl von Behauptungsfunktionen, mit denen Sie testen können, ob der Rückgabewert einer Funktion oder Methode entspricht unseren Erwartungen. Im Folgenden sind einige der am häufigsten verwendeten Assertionsfunktionen in PHPUnit aufgeführt:

• assertTrue($value): Testen Sie, ob $value wahr ist
• assertFalse($value): Testen Sie, ob $value falsch ist
• assertEquals($expected, $actual) : Testen Sie, ob $actual gleich $expected ist
• assertNotEquals($expected, $actual): Testen Sie, ob $actual nicht gleich $expected ist
• assertSame($expected, $actual): Testen Sie, ob $actual gleich ist das Gleiche wie $expected
• assertNotSame( $expected, $actual): Testen Sie, ob $actual sich von $expected unterscheidet
• assertNull($value): Testen Sie, ob $value null ist
• assertNotNull($value): Testen Sie, ob $ value ist nicht null
• assertInstanceOf($expected , $actual): Testen Sie, ob $actual eine Instanz von $expected ist
• assertNotInstanceOf($expected, $actual): Testen Sie, ob $actual keine Instanz von $expected

ist
5. Verwenden Sie einen Datenanbieter

Manchmal müssen wir testen, ob eine Funktion oder Methode für verschiedene Eingaben das richtige Ergebnis zurückgibt. Zu diesem Zeitpunkt können wir die Datenanbieterfunktion von PHPUnit verwenden. Ein Datenprovider ist eine Methode, die eine Reihe von Parametern bereitstellt, von denen jeder eine Sammlung von Daten darstellt, die getestet werden können.

Im folgenden Beispiel haben wir einen Datenprovider für die Add-Methode der Calculator-Klasse geschrieben, der unterschiedliche Eingabedaten und erwartete Ausgaben bereitstellt.

class CalculatorTest extends TestCase {
    /**
     * @dataProvider additionProvider
     */
    public function testAdd($a, $b, $expected) {
        $calculator = new Calculator();
        $result = $calculator->add($a, $b);
        $this->assertEquals($expected, $result);
    }

    public function additionProvider() {
        return [
            [0, 0, 0],
            [0, 1, 1],
            [1, 0, 1],
            [1, 1, 2],
            [2, 3, 5],
            [-1, 1, 0],
            [10, -5, 5]
        ];
    }
}

In diesem Testfall verwenden wir die Annotation @DataProvider, um PHPUnit mitzuteilen, wo ein Datenanbieter zu finden ist. Wir haben einen Datenanbieter namens „additionProvider“ geschrieben, in dem wir verschiedene Eingabedaten und erwartete Ausgaben bereitstellen. In der Testmethode testAdd haben wir diese Daten direkt übergeben und getestet.

6. Verwendung von Scheinobjekten

Wenn wir eine Methode in einem Objekt testen, möchten wir uns möglicherweise nicht auf andere Klassen oder externe Ressourcen verlassen. Zu diesem Zeitpunkt können wir das Mock-Objekt von PHPUnit verwenden, um diese Abhängigkeiten zu simulieren. Ein Scheinobjekt ist ein Scheinobjekt, das dieselbe Schnittstelle bereitstellt, aber nicht tatsächlich instanziiert wird.

Im folgenden Beispiel haben wir ein Mock-Objekt für die Add-Methode in der Calculator-Klasse geschrieben, um externe Abhängigkeiten zu simulieren.

class CalculatorTest extends TestCase {
    public function testAdd() {
        $mock = $this->getMockBuilder('Dependency')
                     ->getMock();
        $mock->expects($this->once())
             ->method('getValue')
             ->will($this->returnValue(5));

        $calculator = new Calculator($mock);
        $result = $calculator->add(2, 3);
        $this->assertEquals(10, $result);
    }
}

In diesem Testfall verwenden wir die getMockBuilder-Methode, um ein Mock-Objekt namens Dependency zu erstellen. Dann erwarten wir, dass die getValue-Methode des Mock-Objekts einmal aufgerufen wird und 5 zurückgibt. Schließlich übergeben wir dieses Mock-Objekt an den Konstruktor der Calculator-Klasse.

Zusammenfassung

In diesem Artikel haben wir gelernt, wie man PHPUnit für PHP-Unit-Tests verwendet. Wir haben PHPUnit installiert, Testfälle geschrieben, die Testfälle ausgeführt und Assertionen, Datenanbieter und Mock-Objekte verwendet. Durch diese Schritte können wir hochwertige Testfälle schreiben, um unseren Code zu testen, um die Codequalität zu verbessern und Entwicklung und Wartung zu beschleunigen.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie PHPUnit für PHP-Unit-Tests. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!