Guzzle-klientide testimine

Guzzle pakub mitmeid tööriistu, mis võimaldavad teil hõlpsasti jäljendada HTTP-kihti, ilma et peaksite päringuid üle interneti saatma.

• Mock handler
• Ajalooline kesktarkvara
• Node.js veebiserver integratsiooni testimiseks

Mock-handler

HTTP-klientide testimisel on sageli vaja simuleerida konkreetseid stsenaariume, näiteks eduka vastuse tagastamine, vea tagastamine või konkreetsete vastuste tagastamine. vastuseid teatud järjekorras. Kuna ühiktestid peavad olema prognoositavad, lihtsad käivitatav ja kiire, on tegeliku kaugjuhtimispiirkonna API tabamine testilõhn.

Guzzle pakub mock-handlerit, mida saab kasutada HTTP-päringute täitmiseks vastuse või erandiga, nihutades tagastusväärtused järjekorrast välja.

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

Kui järjekorras ei ole enam vastuseid ja taotlus saadetakse, visatakse OutOfBoundsException.

History Middleware

Kui kasutate selliseid asju nagu Mock käsitseja, peate sageli teadma, kas oodatud päringud saadeti täpselt nii, nagu te kavatsesite. Kuigi mock käsitseja vastab mockitud vastustega, säilitab history middleware'i ajalugu ajalugu kliendi poolt saadetud taotluste kohta.

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 veebiserver

Veebiteenuse kliendi testimisel piisab peaaegu alati mock-vastuste kasutamisest. Kohandatud HTTP-handlerite rakendamisel tuleb teil peate saatma tegelikke HTTP-päringuid, et piisavalt testida käitlejat. Parim tava on siiski võtta ühendust pigem kohaliku veebiserveriga kui serveriga Interneti kaudu.

• Testid on usaldusväärsemad
• Testid ei nõua võrguühendust
• Testidel ei ole väliseid sõltuvusi

Testserveri kasutamine

Hoiatus

Guzzle'i arendajate abistamiseks on ette nähtud järgmine funktsionaalsus arendada HTTP-käsitlejaid. Tagasiühilduvust ei lubata. kui tegemist on node.js testserveri või GuzzleHttp\Tests\Server klassi. Kui kasutate testserverit või Server klassi väljaspool guzzlehttp/guzzle, siis tuleb teil konfigureerida autoloading ja tagada veebiserveri käivitamine käsitsi.

Vihje

Seda testveebiserverit ei ole peaaegu kunagi vaja kasutada. Te peaksite alati ainult kaaluda selle kasutamist HTTP-käsitlejate arendamisel. Testi veebiserver ei ole vajalik päringute mõtestamiseks. Selleks kasutage palun Mock handler ja history middleware'i.

Guzzle'ile on lisatud node.js testserver, mis võtab vastu päringuid ja tagastab vastuseid järjekorrast. Testserver avaldab lihtsa API, mida kasutatakse selleks, et kasutada vastuste järjekorda seadmiseks ja saadud päringute kontrollimiseks.

Iga operatsioon Server objektiga tagab, et Server tagab, et server töötab ja ootab, kuni see on võimeline päringuid vastu võtma, enne kui tagastamist.

GuzzleHttp\Tests\Server pakub staatilist liidest testiserverile. Sa saab järjekorda seada HTTP-vastuse või vastuste massiivi, kutsudes üles Server::enqueue(). See meetod võtab vastu massiivi Psr\Http\Message\ResponseInterface ja Exception objektid.

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

Kui vastus on testserveri järjekorda pandud, eemaldab testserver mis tahes varem järjekorda pandud vastused. Kui server saab päringuid, siis järjekorda seatud vastused järjekorda ja tagastatakse päringule. Kui järjekord on tühi, vastab server tagastab vastuse 500.

Saate kontrollida taotlusi, mille server on kätte saanud, kutsudes Server::received().

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

Saate veebiserverist saadud päringute nimekirja kustutada, kasutades meetodit Server::flush().

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