Guzzle oferă mai multe instrumente care vă vor permite să vă bateți joc cu ușurință de stratul HTTP fără a fi nevoie să trimiteți cereri pe internet.
Atunci când testați clienții HTTP, aveți adesea nevoie să simulați scenarii specifice, cum ar fi returnarea unui răspuns de succes, returnarea unei erori sau returnarea unui răspuns specific. răspunsuri într-o anumită ordine. Deoarece testele unitare trebuie să fie previzibile, ușor de să fie ușor de inițializat și rapid, atingerea unei API reale la distanță este un miros de test.
Guzzle oferă un manipulator simulat care poate fi utilizat pentru a îndeplini cererile HTTP cu un răspuns sau o excepție prin deplasarea valorilor de returnare dintr-o coadă.
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
Atunci când nu mai sunt răspunsuri în coada de așteptare și se trimite o cerere, se aruncă o OutOfBoundsException.
Atunci când folosiți lucruri precum Mock handler, aveți adesea nevoie să știți dacă
cererile pe care vă așteptați să le trimiteți au fost trimise exact așa cum ați dorit. În timp ce mock
handler răspunde cu răspunsuri simulate, middleware-ul de istoric păstrează un
istoricul cererilor care au fost trimise de către 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.
}
Utilizarea răspunsurilor simulate este aproape întotdeauna suficientă atunci când se testează un client de servicii web. Atunci când implementați HTTP handlers personalizați, veți nevoie să trimiteți cereri HTTP reale pentru a testa suficient de bine gestionarul. Cu toate acestea, cea mai bună practică este să contactați un server web local, mai degrabă decât un server pe internet.
Avertisment
Următoarele funcționalități sunt furnizate pentru a ajuta dezvoltatorii de Guzzle
să dezvolte gestionari HTTP. Nu există nicio promisiune de compatibilitate retroactivă
atunci când vine vorba de serverul de testare node.js sau de GuzzleHttp\Tests\Server
clasă. Dacă utilizați serverul de testare sau clasa Server în afara clasei
guzzlehttp/guzzle, atunci va trebui să configurați autoloading și
să vă asigurați că serverul web este pornit manual.
Indiciu
Aproape niciodată nu va fi nevoie să utilizați acest server web de testare. Ar trebui doar să luați în considerare utilizarea acestuia atunci când dezvoltați gestionari HTTP. Serverul web de testare nu este necesar pentru simularea cererilor. În acest scop, vă rugăm să utilizați Mock handler și middleware-ul istoric.
Guzzle este livrat cu un server de testare node.js care primește cereri și returnează răspunsuri dintr-o coadă. Serverul de testare expune un API simplu care este utilizat pentru a a pune în coadă răspunsurile și a inspecta cererile pe care le-a primit.
Orice operațiune asupra obiectului Server se va asigura că
serverul este în funcțiune și va aștepta până când acesta este capabil să primească cereri înainte de a
să se întoarcă.
GuzzleHttp\Tests\Server oferă o interfață statică pentru serverul de testare. Puteți
puteți pune în coadă un răspuns HTTP sau o matrice de răspunsuri prin apelarea
Server::enqueue(). Această metodă acceptă o matrice de
Psr\Http\Message\ResponseInterface și obiecte 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
Atunci când un răspuns este pus în coadă pe serverul de testare, serverul de testare va elimina orice răspunsurile puse anterior în coadă. Pe măsură ce serverul primește cereri, răspunsurile din coada de așteptare sunt scoase din coadă și returnate la cerere. Atunci când coada este goală, serverul va returna un răspuns 500.
Puteți inspecta cererile pe care le-a recuperat serverul prin apelarea Server::received().
foreach (Server::received() as $response) {
echo $response->getStatusCode();
}
Puteți șterge lista de cereri primite de la serverul web utilizând metoda Server::flush().
Server::flush();
echo count(Server::received());
// 0