Guzzle klientu testēšana

Guzzle nodrošina vairākus rīkus, kas ļauj viegli izspēlēt HTTP slāni bez nepieciešamības sūtīt pieprasījumus internetā.

• Apstrādātāja makets
• Vēstures starpprogrammatūra
• Node.js tīmekļa serveris integrācijas testēšanai

Mock Handler

Testējot HTTP klientus, bieži ir nepieciešams simulēt īpašus scenārijus, piemēram. sekmīgas atbildes atgriešana, kļūdas atgriešana vai konkrētu atbildes signālu atgriešana. atbildes noteiktā secībā. Tā kā vienības testiem ir jābūt paredzamiem, viegli un ātra palaišana, testēšana ar faktisko attālo API ir testēšanas smārds.

Guzzle nodrošina izspēles apstrādātāju, ko var izmantot, lai izpildītu HTTP pieprasījumus ar atbildi vai izņēmumu, pārvietojot atgrieztās vērtības no rindas.

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

Ja rindā vairs nav atbilžu un tiek nosūtīts pieprasījums, tiek izmests OutOfBoundsException.

History Middleware

Lietojot, piemēram, Mock apstrādātāju, bieži vien ir nepieciešams zināt, vai. vai pieprasījumi, kurus bija paredzēts nosūtīt, tika nosūtīti tieši tā, kā bijāt iecerējis. Lai gan mock apstrādātājs atbild ar izspēlētu atbildi, vēstures starpprogrammatūra saglabā klienta nosūtīto pieprasījumu vēsturi.

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

Testa tīmekļa serveris

Testējot tīmekļa pakalpojuma klientu, gandrīz vienmēr ir pietiekami izmantot izspēles atbildes. Īstenojot pielāgotus HTTP apstrādātājus, jūs būs nepieciešams sūtīt faktiskus HTTP pieprasījumus, lai apstrādātāju varētu pietiekami pārbaudīt. Tomēr labākā prakse ir sazināties ar vietējo tīmekļa serveri, nevis serveri. izmantojot internetu.

• Testi ir uzticamāki
• Testiem nav nepieciešams tīkla savienojums
• Testiem nav ārēju atkarību

Testa servera izmantošana

Brīdinājums

Guzzle izstrādātājiem tiek nodrošināta šāda funkcionalitāte. izstrādāt HTTP apstrādātājus. Nav solīta atpakaļejošā savietojamība. kad runa ir par node.js testu serveri vai GuzzleHttp\Tests\Server. klase. Ja izmantojat testa serveri vai Server klasi ārpus guzzlehttp/guzzle, tad jums būs jākonfigurē automātiskā ielādēšana un jānodrošina, ka tīmekļa serveris tiek palaists manuāli.

Padoms

Šis testa tīmekļa serveris gandrīz nekad nav jāizmanto. Jums vienmēr vajadzētu tikai apsvērt tā izmantošanu, izstrādājot HTTP apstrādātājus. Testa tīmekļa serveris nav nepieciešams, lai izspēlētu pieprasījumus. Šim nolūkam izmantojiet Mock handler un vēstures starpprogrammatūru.

Guzzle tiek piegādāts ar mezgla.js testa serveri, kas saņem pieprasījumus un atgriež atbildes no rindas. Testa serveris piedāvā vienkāršu API, ko izmanto, lai atbildēm un pārbaudītu saņemtos pieprasījumus.

Jebkura darbība ar Serveris objektu nodrošinās, ka. serveris darbojas, un nogaidīs, kamēr tas varēs saņemt pieprasījumus, un tad atgriežot.

GuzzleHttp\Tests\Server nodrošina statisku saskarni ar testa serveri. Jūs var izveidot rindā HTTP atbildi vai atbilžu masīvu, izsaucot Server::enqueue(). Šī metode pieņem masīvu Psr\Http\Message\ResponseInterface un Exception objektu.

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

Kad testa serverī atbilde ir gaidīšanas rindā, testa serveris noņem visus iepriekš rindā atstātās atbildes. Kad serveris saņem pieprasījumus, rindā atstātās atbildes tiek noņemtas no rindas un atdotas atpakaļ pieprasījumam. Kad rinda ir tukša, serveris tiks atgriezta atbilde 500.

Jūs varat pārbaudīt servera saņemtos pieprasījumus, izsaucot Server::received().

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

No tīmekļa servera saņemto pieprasījumu sarakstu var izdzēst, izmantojot Server::flush() metodi.

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