Guzzle klientų testavimas

"Guzzle" pateikia keletą įrankių, kurie leidžia lengvai tyčiotis iš HTTP sluoksnio nesiunčiant užklausų internetu.

  • Pašiepiamasis tvarkytuvas
  • Istorijos tarpinė programinė įranga
  • "Node.js" žiniatinklio serveris, skirtas integracijos bandymams

Mock Handler

Testuojant HTTP klientus dažnai reikia imituoti konkrečius scenarijus, pvz. sėkmingo atsakymo grąžinimą, klaidos grąžinimą arba konkrečių atsakymų grąžinimą. atsakymus tam tikra tvarka. Kadangi vieneto testai turi būti nuspėjami, lengvai paleisti ir greiti, bandymų kvapas - pataikyti į tikrą nuotolinę API.

"Guzzle" pateikia pasityčiojimo tvarkyklę, kurią galima naudoti HTTP užklausoms įvykdyti su atsakymu arba išimtimi perkeliant grąžinimo reikšmes iš eilės.

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

Kai eilėje nebėra atsakymų ir siunčiama užklausa, išmetama OutOfBoundsException.

History Middleware

Naudojant tokius dalykus kaip Mock tvarkyklė, dažnai reikia žinoti, ar užklausos, kurias tikėjotės išsiųsti, buvo išsiųstos būtent taip, kaip norėjote. Nors mock tvarkyklė atsakinėja pašiepiamais atsakymais, istorijos tarpinė programinė įranga palaiko kliento išsiųstų užklausų istoriją.

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

Bandomasis žiniatinklio serveris

Testuojant žiniatinklio paslaugos klientą beveik visada pakanka naudoti imitacinius atsakymus. Įgyvendindami pasirinktinius HTTP tvarkykles, turėsite norint pakankamai išbandyti tvarkytuvą, reikės siųsti tikras HTTP užklausas. Tačiau geriausia praktika yra kreiptis į vietinį žiniatinklio serverį, o ne į serverį per internetą.

  • Testai yra patikimesni
  • Bandymams nereikalingas tinklo ryšys
  • Testai neturi išorinių priklausomybių

Bandomojo serverio naudojimas

Įspėjimas

"Guzzle" kūrėjams padeda šios funkcijos kurti HTTP tvarkykles. Atgalinis suderinamumas nežadamas kai kalbama apie node.js bandymų serverį arba GuzzleHttp\Tests\Server klasė. Jei naudojate bandymų serverį arba Server klasę už guzzlehttp/guzzle, tuomet turėsite sukonfigūruoti automatinį įkrovimą ir užtikrinti, kad žiniatinklio serveris būtų paleistas rankiniu būdu.

Užuomina

Šio bandomojo žiniatinklio serverio beveik niekada nereikės naudoti. Turėtumėte tik jį naudoti kuriant HTTP tvarkykles. Bandomasis žiniatinklio serveris nereikalingas užklausoms pašiepti. Tam naudokite Mock handler ir history middleware.

"Guzzle" tiekiamas su node.js bandymų serveriu, kuris gauna užklausas ir grąžina atsakymus iš eilės. Bandymų serveris pateikia paprastą API, kuri naudojama įrašyti atsakymus į eilę ir patikrinti gautas užklausas.

Bet kokia operacija su Serveris objektu užtikrins, kad serveris veikia ir laukia, kol jis galės priimti užklausas, ir tik tada grįžta.

GuzzleHttp\Tests\Server suteikia statinę sąsają su testavimo serveriu. Jūs HTTP atsakymą arba atsakymų masyvą galite įrašyti į eilę skambindami Server::enqueue(). Šis metodas priima masyvą Psr\Http\Message\ResponseInterface ir 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

Kai testavimo serveryje į eilę įrašomas atsakymas, testavimo serveris pašalina visus anksčiau į eilę įrašytus atsakymus. Kai serveris gauna užklausas, į eilę įrašyti atsakymai išbraukiami iš eilės ir grąžinami į užklausą. Kai eilė ištuštėja, serveris bus grąžinamas 500 atsakymas.

Užklausas, kurias gavo serveris, galite patikrinti iškvietę Server::received().

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

Gautų užklausų iš žiniatinklio serverio sąrašą galite išvalyti naudodami Server::flush() metodą.

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