Tester les clients de Guzzle

Guzzle fournit plusieurs outils qui vous permettront de simuler facilement la couche HTTP sans avoir besoin d'envoyer des requêtes sur Internet.

• Gestionnaire fantaisie
• Middleware d'histoire
• Serveur web Node.js pour les tests d'intégration

Mock Handler

Lorsque vous testez des clients HTTP, vous devez souvent simuler des scénarios spécifiques tels que le retour d'une réponse réussie, le retour d'une erreur ou le retour de réponses réponses spécifiques dans un certain ordre. Parce que les tests unitaires doivent être prévisibles, faciles à mettre en place et rapides. faciles à amorcer et rapides, l'utilisation d'une API distante réelle est une odeur de test.

Guzzle fournit un gestionnaire de simulacre qui peut être utilisé pour répondre aux requêtes HTTP avec une réponse ou une exception en décalant les valeurs de retour d'une file d'attente.

use GuzzleHttp\Client;
use GuzzleHttp\Handler\MockHandler;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Psr7\Response;
use GuzzleHttp\Psr7\Request;
use GuzzleHttp\Exception\RequestException;

// Create a mock and queue two responses.
$mock = new MockHandler([
    new Response(200, ['X-Foo' => 'Bar'], 'Hello, World'),
    new Response(202, ['Content-Length' => 0]),
    new RequestException('Error Communicating with Server', new Request('GET', 'test'))
]);

$handlerStack = HandlerStack::create($mock);
$client = new Client(['handler' => $handlerStack]);

// The first request is intercepted with the first response.
$response = $client->request('GET', '/');
echo $response->getStatusCode();
//> 200
echo $response->getBody();
//> Hello, World
// The second request is intercepted with the second response.
echo $client->request('GET', '/')->getStatusCode();
//> 202

// Reset the queue and queue up a new response
$mock->reset();
$mock->append(new Response(201));

// As the mock was reset, the new response is the 201 CREATED,
// instead of the previously queued RequestException
echo $client->request('GET', '/')->getStatusCode();
//> 201

Lorsqu'il n'y a plus de réponses dans la file d'attente et qu'une demande est envoyée, une Exception OutOfBounds est levée.

Middleware d'histoire

Lorsque vous utilisez des éléments tels que le gestionnaire Mock, vous avez souvent besoin de savoir si les demandes que vous vous attendiez à envoyer ont été envoyées exactement comme vous le souhaitiez. Alors que le gestionnaire mock répond avec des réponses simulées, le middleware d'historique maintient un historique des demandes envoyées par un client.

use GuzzleHttp\Client;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Middleware;

$container = [];
$history = Middleware::history($container);

$handlerStack = HandlerStack::create();
// or $handlerStack = HandlerStack::create($mock); if using the Mock handler.

// Add the history middleware to the handler stack.
$handlerStack->push($history);

$client = new Client(['handler' => $handlerStack]);

$client->request('GET', 'http://httpbin.org/get');
$client->request('HEAD', 'http://httpbin.org/get');

// Count the number of transactions
echo count($container);
//> 2

// Iterate over the requests and responses
foreach ($container as $transaction) {
    echo $transaction['request']->getMethod();
    //> GET, HEAD
    if ($transaction['response']) {
        echo $transaction['response']->getStatusCode();
        //> 200, 200
    } elseif ($transaction['error']) {
        echo $transaction['error'];
        //> exception
    }
    var_dump($transaction['options']);
    //> dumps the request options of the sent request.
}

Test Web Server

L'utilisation de réponses fictives est presque toujours suffisante pour tester un client de service Web. Lorsque vous implémentez des gestionnaires HTTP personnalisés HTTP handlers, vous devrez envoyer des requêtes HTTP réelles afin de tester suffisamment le gestionnaire. vous devrez envoyer des requêtes HTTP réelles afin de tester suffisamment le gestionnaire. Cependant, une meilleure pratique consiste à contacter un serveur web local plutôt qu'un serveur sur Internet.

• Les tests sont plus fiables
• Les tests ne nécessitent pas de connexion réseau
• Les tests n'ont pas de dépendances externes

Utilisation du serveur de test

Avertissement

La fonctionnalité suivante est fournie pour aider les développeurs de Guzzle à à développer des gestionnaires HTTP. Il n'y a aucune promesse de rétrocompatibilité en ce qui concerne le serveur de test node.js ou la GuzzleHttp\Tests\Server . Si vous utilisez le serveur de test ou la classe Server en dehors de la classe guzzlehttp/guzzle, vous devrez alors configurer le chargement automatique et vous assurer que le serveur Web est démarré manuellement.

Indice

Vous n'avez presque jamais besoin d'utiliser ce serveur web de test. Vous devriez seulement envisager de l'utiliser pour développer des gestionnaires HTTP. Le serveur web de test n'est pas nécessaire pour simuler des requêtes. Pour cela, veuillez utiliser le Mock handler et history middleware.

Guzzle est livré avec un serveur de test node.js qui reçoit des demandes et renvoie des réponses à partir d'une file d'attente. réponses à partir d'une file d'attente. Le serveur de test expose une API simple qui est utilisée pour mettre en file d'attente les réponses et inspecter les demandes qu'il a reçues.

Toute opération sur l'objet Serveur s'assurera que serveur est en cours d'exécution et attendra qu'il soit en mesure de recevoir des demandes avant de de revenir.

GuzzleHttp\Tests\Server fournit une interface statique au serveur de test. Vous pouvez mettre en file d'attente une réponse HTTP ou un tableau de réponses en appelant Server::enqueue(). Cette méthode accepte un tableau de Psr\Http\Message\ResponseInterface et Exception.

use GuzzleHttp\Client;
use GuzzleHttp\Psr7\Response;
use GuzzleHttp\Tests\Server;

// Start the server and queue a response
Server::enqueue([
    new Response(200, ['Content-Length' => 0])
]);

$client = new Client(['base_uri' => Server::$url]);
echo $client->request('GET', '/foo')->getStatusCode();
// 200

Lorsqu'une réponse est mise en file d'attente sur le serveur de test, ce dernier supprime toutes les réponses précédemment mises en file d'attente. réponses précédemment mises en file d'attente. Lorsque le serveur reçoit des demandes, les réponses mises en file d'attente sont retirées de la file d'attente et renvoyées à la demande. Lorsque la file d'attente est vide, le serveur renvoie une réponse 500.

Vous pouvez inspecter les demandes que le serveur a récupérées en appelant Server::received().

foreach (Server::received() as $response) {
    echo $response->getStatusCode();
}

Vous pouvez effacer la liste des demandes reçues du serveur Web en utilisant la méthode Server::flush().

Server::flush();
echo count(Server::received());
// 0