Testowanie klientów Guzzle

Guzzle udostępnia kilka narzędzi, które pozwolą Ci w prosty sposób zakpić z warstwy HTTP bez konieczności wysyłania żądań przez internet.

• Przykładowy handler
• Oprogramowanie pośredniczące do tworzenia historii
• Serwer webowy Node.js do testów integracyjnych

Mock Handler

Podczas testowania klientów HTTP, często trzeba symulować określone scenariusze, takie jak zwrócenie udanej odpowiedzi, zwrócenie błędu, lub zwrócenie określonych odpowiedzi w określonej kolejności. Ponieważ testy jednostkowe muszą być przewidywalne, łatwe łatwe do uruchomienia i szybkie, uderzanie w rzeczywiste, zdalne API jest zapachowym elementem testów.

Guzzle dostarcza mock handler, który może być użyty do wypełniania żądań HTTP z odpowiedzią lub wyjątkiem poprzez przesunięcie wartości zwracanych z kolejki.

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

Gdy w kolejce nie ma już żadnych odpowiedzi, a żądanie jest wysyłane, rzucany jest wyjątek OutOfBoundsException.

History Middleware

Kiedy używasz rzeczy takich jak Mock, często potrzebujesz wiedzieć, czy żądania, które spodziewałeś się wysłać czy żądania, które spodziewałeś się wysłać, zostały wysłane dokładnie tak, jak zamierzałeś. Podczas gdy mock odpowiada wyśmiewanymi odpowiedziami, oprogramowanie pośredniczące historii utrzymuje historię żądań, które zostały wysłane przez klienta.

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

Testowy serwer WWW

Używanie kpiących odpowiedzi jest prawie zawsze wystarczające podczas testowania klienta usługi sieciowej. Kiedy implementujesz niestandardowe HTTP handlers, będziesz potrzebował musisz wysyłać rzeczywiste żądania HTTP, aby wystarczająco przetestować handler. Jednakże, najlepszą praktyką jest kontaktowanie się z lokalnym serwerem WWW, a nie z serwerem przez Internet.

• Testy są bardziej wiarygodne
• Testy nie wymagają połączenia z siecią
• Testy nie mają zewnętrznych zależności

Korzystanie z serwera testowego

Ostrzeżenie

Poniższa funkcjonalność została udostępniona, aby pomóc programistom Guzzle w tworzeniu obsługi HTTP. Nie ma obietnicy kompatybilności wstecznej jeśli chodzi o serwer testowy node.js lub klasę GuzzleHttp\Tests\Server klasa. Jeśli używasz serwera testowego lub klasy Server poza klasą guzzlehttp/guzzle, to będziesz musiał skonfigurować autoloading i upewnić się, że serwer WWW jest uruchamiany ręcznie.

Wskazówka

Prawie nigdy nie musisz używać tego testowego serwera WWW. Powinieneś jedynie rozważać jego użycie podczas tworzenia handlerów HTTP. Testowy serwer WWW nie jest konieczny do wyśmiewania żądań. Do tego celu należy użyć Mock handler i history middleware.

Guzzle dostarcza serwer testowy node.js, który odbiera żądania i zwraca odpowiedzi z kolejki. Serwer testowy udostępnia proste API, które jest używane do zapisywania odpowiedzi i sprawdzania otrzymanych żądań.

Każda operacja na obiekcie Server zapewni, że że serwer jest uruchomiony i poczeka, aż będzie w stanie przyjmować żądania przed powrotem.

GuzzleHttpTestserver udostępnia statyczny interfejs do serwera testowego. Użytkownik możesz ustawić w kolejce odpowiedź HTTP lub tablicę odpowiedzi, wywołując Server::enqueue(). Metoda ta przyjmuje tablicę Psr\Message\ResponseInterface oraz Exception obiektów.

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

Gdy odpowiedź zostanie umieszczona w kolejce na serwerze testowym, serwer testowy usunie wszystkie wcześniej ustawione w kolejce odpowiedzi. Gdy serwer otrzymuje żądania, odpowiedzi ustawiane w kolejce są usuwane z kolejki i zwracane do żądania. Kiedy kolejka jest pusta, serwer zwróci odpowiedź 500.

Możesz sprawdzić żądania, które zostały pobrane przez serwer wywołując Server::received().

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

Możesz wyczyścić listę odebranych żądań z serwera WWW używając metody Server::flush().

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