API client testing

@tisuchi thanks, for whatever reason, my Controller made an actual call out to the URL, it was as though Http::fake had no effect

I noticed https://github.com/laravel/slack-notification-channel/blob/3.x/tests/NotificationSlackChannelTest.php#L33 also using Guzzle directly, makes me wonder why Laravel doesn't use it's own Http facade

I made a minimum example still causing the error

namespace App\Tests;

use App\Token;
use App\Tests\TestbenchTestCase;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Foundation\Testing\WithoutMiddleware;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Http;
use Mockery as m;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\StreamInterface;

/**
 * Test the API calls are formed correctly
 */
class TokenTest extends TestbenchTestCase
{
    use RefreshDatabase;
    use WithoutMiddleware;

    protected function tearDown(): void
    {
        parent::tearDown();

        m::close();
    }

    public function test_it_can_map_a_user_without_an_email_address()
    {
        $request = m::mock(Request::class);
        $request->allows('input')->with('code')->andReturns('fake-code');

        $stream = m::mock(StreamInterface::class);
        $stream->allows('__toString')->andReturns(json_encode(['access_token' => 'fake-token']));

        $accessTokenResponse = m::mock(ResponseInterface::class);

        $accessTokenResponse->allows('getBody')->andReturns($stream);

        $basicProfileStream = m::mock(StreamInterface::class);
        $basicProfileStream->allows('__toString')->andReturns(json_encode(['id' => $userId = 1]));

        $basicProfileResponse = m::mock(ResponseInterface::class);
        $basicProfileResponse->allows('getBody')->andReturns($basicProfileStream);

        $emailAddressStream = m::mock(StreamInterface::class);
        $emailAddressStream->allows('__toString')->andReturns(json_encode(['elements' => []]));

        $emailAddressResponse = m::mock(ResponseInterface::class);
        $emailAddressResponse->allows('getBody')->andReturns($emailAddressStream);

        Http::fake([
            'https://example.com/oauth2/token' => Http::response($accessTokenResponse),
        ]);

        $provider = new Token($request, 'client_id', 'client_secret', 'redirect');
        $referral_id = $provider
            ->getOauth2Token();

    }
}

namespace App\Token;

use Exception;
use GuzzleHttp\Client;
use Http;
use Illuminate\Http\Request;

class Token
{
    private $accessToken = null;

    private $trackingId = null;

    private $returnUrl = null;

    protected $version = 2;

    protected $body;

    protected Client $httpClient;

    /**
     * Create a new provider instance.
     *
     * @param  string  $clientId
     * @param  string  $clientSecret
     * @param  string  $redirectUrl
     * @param  array  $guzzle
     * @return void
     */
    public function __construct(Request $request, $clientId, $clientSecret, $redirectUrl, $guzzle = [])
    {
        $this->guzzle = $guzzle;
        $this->request = $request;
        $this->clientId = $clientId;
        $this->redirectUrl = $redirectUrl;
        $this->clientSecret = $clientSecret;
    }

    /**
     * Indicates that the provider should operate as stateless.
     *
     * @return $this
     */
    public function stateless()
    {
        $this->stateless = true;

        return $this;
    }

    /**
     * Set the Guzzle HTTP client instance.
     *
     * @return $this
     */
    public function setHttpClient(Client $client)
    {
        $this->httpClient = $client;

        return $this;
    }

    public function getOauth2Token()
    {
        $client = 'client';
        $secret = 'secret';

        $url = 'https://example.com/oauth2/token';
        $response = Http::acceptJson()
            ->withBasicAuth($client, $secret)
            ->asForm()
            ->withHeaders([
                'Accept-Language' => 'en_US',
            ])
            ->post($url, [
                'grant_type' => 'client_credentials',
            ]);

        $json = $response->json();

        if (! isset($json['access_token'])) {
            throw new Exception('Unable to get token');
        }

        return $json['access_token'];
    }
}