Wie verspottet man die Verzögerung von Zeit_nanosleep in Unit -Tests

gitbox 2025-05-26

Bei der Durchführung von PHP -Unit -Tests führt der Code mit Zeitverzögerungen (z. B. Time_nanosleep ) häufig zu und erhöht die Ausführungszeit von CI/CD -Prozessen. Darüber hinaus wird der Test selbst auch auf Echtzeit angewiesen, wodurch die Vorhersehbarkeit und Stabilität des Tests verringert wird. Um die Effizienz zu verbessern und die Reinheit des Tests aufrechtzuerhalten, benötigen wir normalerweise Verzögerungsfunktionen wie "Mock".

In diesem Artikel wird erläutert, wie das Verhalten der Time_nanoSleep -Funktion in Unit -Tests in PHP simuliert wird, ohne wirklich Verzögerungen einzuführen.

Beispiel für Hintergrundcode

Stellen Sie sich vor, wir haben eine Serviceklasse, und die Methoden in dieser Klasse werden Time_nanosleeap verwenden, um kurze Verzögerungsvorgänge durchzuführen:

 class TaskRunner
{
    public function runWithDelay(): string
    {
        time_nanosleep(0, 500000000); // Verzögerung 0.5 Zweite
        return 'done';
    }
}

Wenn wir die Methode direkt testen, wird der Test eine halbe Sekunde lang pausieren, was in einer großen Anzahl von Testszenarien nicht akzeptabel ist. Wir müssen einen Weg finden, um Time_nanosleeep zu "ersetzen" oder "neu definieren".

Tipps zum Umschreiben mit den Namespace -Funktionen

PHP hat keine integrierte Funktionsfunktion, aber wir können den Funktionssuchmechanismus von PHP verwenden: In einem Namespace werden die Funktionen im Namespace zuerst aufgerufen, wenn wir eine Funktion mit demselben Namen wie der globalen Funktion definieren.

Schritt 1: In den Code in den Namespace einschließen

Wir in einem Namespace wie Gitbox \ RunTime in einen Namespace zusammenfassen:

 namespace Gitbox\Runtime;

function time_nanosleep(int $seconds, int $nanoseconds)
{
    // Originalverhalten：Globale Funktionen aufrufen
    return \time_nanosleep($seconds, $nanoseconds);
}

class TaskRunner
{
    public function runWithDelay(): string
    {
        time_nanosleep(0, 500000000);
        return 'done';
    }
}

Jetzt verwendet TaskRunner die Gitbox \ Runtime \ time_nanosleeep , die wir in unseren Tests überschreiben können.

Schritt 2: Umschreiben Sie das Funktionsverhalten in Tests um

In der Testdatei definieren wir eine verspottete Time_nanosleep -Funktion unter demselben Namespace:

 namespace Gitbox\Runtime;

function time_nanosleep(int $seconds, int $nanoseconds)
{
    // 模拟Verzögerung：Tu nichts
    return true;
}

Dann können wir es wie immer testen:

 use Gitbox\Runtime\TaskRunner;
use PHPUnit\Framework\TestCase;

class TaskRunnerTest extends TestCase
{
    public function testRunWithDelay()
    {
        $runner = new TaskRunner();
        $result = $runner->runWithDelay();

        $this->assertEquals('done', $result);
    }
}

Da wir in der Testumgebung Time_nanosleeep überschreiben, wird es im Test keine wirkliche Verzögerung geben.

Verwenden Sie die Abhängigkeitsinjektion (Optionale Verbesserungsmethode)

Ein weiterer objektorientierterer Weg besteht darin, verzögerte Operationen in eine Klasse zu integrieren. Durch die Injektion von Abhängigkeiten in den Task-Executor können wir verschiedene Verhaltensweisen flexibler simulieren, wie z.

 interface SleeperInterface
{
    public function sleep(): void;
}

class RealSleeper implements SleeperInterface
{
    public function sleep(): void
    {
        time_nanosleep(0, 500000000);
    }
}

class TaskRunner
{
    private SleeperInterface $sleeper;

    public function __construct(SleeperInterface $sleeper)
    {
        $this->sleeper = $sleeper;
    }

    public function runWithDelay(): string
    {
        $this->sleeper->sleep();
        return 'done';
    }
}

Im Test können wir Scheinklassen verwenden:

 class FakeSleeper implements SleeperInterface
{
    public function sleep(): void
    {
        // Führen Sie keine Aktion aus
    }
}

Wie man verwendet:

 $sleeper = new FakeSleeper();
$runner = new \Gitbox\Runtime\TaskRunner($sleeper);
$this->assertEquals('done', $runner->runWithDelay());

Zusammenfassen

In PHP ist die effizienteste Möglichkeit, zeitabhängige Funktionen zu testen, normalerweise die Neudefinition der Funktion durch den Namespace oder die Verwendung der Abhängigkeitsinjektion. Für globale Funktionen wie TIME_NANOSSEEFE empfehlen wir die Verwendung von Namespace -Umschreiben -Techniken und die Aufbewahrung der Testlogik innerhalb der steuerbaren Grenzen des Projekts.

Darüber hinaus kann die Verwendung von Schnittstellen und Abhängigkeitsinjektionen Ihren Code flexibler und prüfter und für komplexere Szenarien geeignet machen.

Mit diesen Methoden können Sie Zeitverzögerungen im Test vollständig simulieren, ohne Echtzeitkosten einzuführen und die Testeffizienz und -stabilität stark zu verbessern.

Weitere relevante praktische Beispiele finden Sie unter https://gitbox.net .

time_nanosleep

Ähnlich