This is a port of @adamwathan's ZTTP Guzzle convenience layer. It provides much nicer syntax for the 90% use case of Guzzle where you just need to POST some JSON to an endpoint. In addition, this supplements ZTTP with stubbing / faking inspired by @jasonmccreary's work on that library.

This is not an entirely new client - it is only a UX / DX convenience layer on top of Guzzle. We will not be adding a lot of complicated features to this. If you need very, very robust or complicated logic just use Guzzle directly. We aren't trying to expose every feature of Guzzle through this API.

Basic Usage Overview

use Illuminate\Support\Facades\Http;

$response = Http::post('url', [
    'name' => 'Taylor',
]);

echo $response['foo'];

$response->body()
$response->json()
$response->status()
$response->ok()
$response->successful() (>= 200 && < 300)
$response->serverError()
$response->clientError()

By default, the content type is application/json. You may also easily send form-urlencoded requests:

$response = Http::asForm()->post('url', [
    'name' => 'Taylor',
]);

You may also send files as multi-part requests:

$response = Http::attach('name', 'stream/contents', 'filename.txt')->post('url');

Headers / Authentication

Headers may be added using the withHeaders method:

$response = Http::withHeaders(['X-Foo' => 'bar'])->post('url', [
    'name' => 'Taylor',
]);

Authorization / bearer tokens...

$response = Http::withToken('token')->post('url', [
    'name' => 'Taylor',
]);

Basic authentication...

$response = Http::withBasicAuth('username', 'password')->post('url', [
    'name' => 'Taylor',
]);

Errors

By default, like ZTTP, exceptions are not thrown on client and server errors. If you receive a response that is not successful and you would like to throw an exception, you may call $response->throw():

$response = Http::post(...);

if (! $response->successful()) {
    $response->throw();
}

Testing / Faking

Like some other services in Laravel, the HTTP client supports faking. When calling Http::fake() without any additional arguments, all responses will be empty 200 level responses:

Http::fake();

$response = Http::post('url');

However, you may stub the responses returned by specific endpoints by passing an array to the fake method, any requests that are not to URLs matching the given pattern will actually be executed. In this example, I will use the Http::response method to quickly generate a stub response that should be returned.

Http::fake([
    'github.com/*' => Http::response([1, 2, 3], 200, ['Headers']),
]);

A final fallback route could also be provided:

Http::fake([
    'github.com/*' => Http::response([1, 2, 3], 200, ['Headers']),
    '*' => Http::response('', 200),
]);

In addition, you could specify a sequence of responses to be returned. These responses will be returned in order as the endpoint is called:

Http::fake([
    '*' => Http::sequence([Http::response('foo', 200), Http::response('bar', 200)]),
]);

Finally, for maximum flexibility you may pass a Closure to Http::fake which can examine the request, perform conditional logic, and return an appropriate response:

Http::fake(function ($request) {
    return Http::response('foo', 200);
});