Testning av Guzzle-klienter

Guzzle innehåller flera verktyg som gör att du enkelt kan manipulera HTTP-skiktet utan att behöva skicka förfrågningar över internet.

• Mock handläggare
• Historisk middleware
• Node.js-webbserver för integrationstestning

Mock Handler

När du testar HTTP-klienter behöver du ofta simulera specifika scenarier, t.ex. återge ett lyckat svar, återge ett fel eller återge specifika svar i en viss ordning. Eftersom enhetstester måste vara förutsägbara, enkla att starta upp och snabba, är det en testlukt att träffa ett verkligt fjärr-API.

Guzzle tillhandahåller en mock-hanterare som kan användas för att uppfylla HTTP-begäranden med ett svar eller undantag genom att flytta returvärden från en kö.

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

När det inte finns några fler svar i kön och en begäran skickas, uppstår ett OutOfBoundsException.

History Middleware

När du använder saker som Mock handläggaren behöver du ofta veta om begäranden som du förväntade dig att skicka skickades exakt som du hade tänkt dig. Medan mock hanteraren svarar med simulerade svar, upprätthåller history middleware en historik över de begäranden som skickades av en klient.

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.
}

Testwebbserver

Det räcker nästan alltid att använda simulerade svar när du testar en webbtjänstklient. När du implementerar anpassade HTTP-handlers, kommer du att skicka faktiska HTTP-förfrågningar för att kunna testa handläggaren på ett tillfredsställande sätt. Det är dock bäst att kontakta en lokal webbserver snarare än en server över internet.

• Testerna är mer tillförlitliga
• Testerna kräver ingen nätverksanslutning
• Testerna har inga externa beroenden

Användning av testservern

Varning

Följande funktionalitet tillhandahålls för att hjälpa utvecklare av Guzzle att utveckla HTTP-hanterare. Det finns inget löfte om bakåtkompatibilitet. när det gäller node.js-testservern eller GuzzleHttp\Tests\Server klass. Om du använder testservern eller Server klassen utanför guzzlehttp/guzzle, måste du konfigurera autoloading och se till att webbservern startas manuellt.

Tips

Du behöver nästan aldrig använda denna testwebbserver. Du bör endast överväga att använda den när du utvecklar HTTP-hanterare. Testwebbservern är inte nödvändig för att manipulera förfrågningar. För detta bör du använda Mock-hanteraren och History middleware.

Guzzle levereras med en node.js-testserver som tar emot förfrågningar och returnerar svar från en kö. Testservern har ett enkelt API som används för att ställa in svar i kö och inspektera de förfrågningar som den har tagit emot.

Alla operationer på Server objektet kommer att säkerställa att servern är igång och väntar tills den kan ta emot förfrågningar innan den innan den återkommer.

GuzzleHttp\Tests\Server ger ett statiskt gränssnitt till testservern. Du kan ställa ett HTTP-svar eller en array av svar i kö genom att anropa Server::enqueue(). Denna metod accepterar en matris av Psr\Http\Message\ResponseInterface och Exception objekt.

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

När ett svar ställs i kö på testservern tar testservern bort eventuella svar som tidigare ställts i kö. När servern tar emot förfrågningar, kommer svaren i kö att och returneras till begäran. När kön är tom, svarar servern återger servern ett 500-svar.

Du kan granska de begäranden som servern har hämtat genom att anropa Server::received().

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

Du kan rensa listan över mottagna förfrågningar från webbservern med hjälp av metoden Server::flush().

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