{

/**

protected $factory;

protected function setUp(): void

{

$this->factory = new Factory;

RequestException::truncate();

}

protected function tearDown(): void

{

Response::flushState();

}

public function testStubbedResponsesAreReturnedAfterFaking()

{

$this->factory->fake();

$response = $this->factory->post('http://laravel.com/test-missing-page');

$this->assertTrue($response->ok());

}

public function testCreatedRequest()

{

$this->factory->fake([

'vapor.laravel.com' => $this->factory::response('', HttpResponse::HTTP_CREATED),

'forge.laravel.com' => $this->factory::response('', HttpResponse::HTTP_OK),

]);

$response = $this->factory->post('http://vapor.laravel.com');

$this->assertTrue($response->created());

$response = $this->factory->post('http://forge.laravel.com');

$this->assertFalse($response->created());

}

public function testFakeResponseHeaderValuesAreSerialized()

{

$response = $this->factory::response('OK', 200, [

'X-Int' => 123,

'X-Null' => null,

'X-False' => false,

'X-Empty' => [],

'X-Laravel-Stringable' => new Stringable('laravel stringable'),

'X-Multiple' => ['first', 123, true, false, null],

])->wait();

$this->assertSame(['123'], $response->getHeader('X-Int'));

$this->assertSame([''], $response->getHeader('X-Null'));

$this->assertSame([''], $response->getHeader('X-False'));

$this->assertSame([''], $response->getHeader('X-Empty'));

$this->assertSame(['laravel stringable'], $response->getHeader('X-Laravel-Stringable'));

$this->assertSame(['first', '123', '1', '', ''], $response->getHeader('X-Multiple'));

}

public function testFakeResponseHeaderValuesNormalizeNonFiniteFloats()

{

$response = $this->factory::response('OK', 200, [

'X-Nan' => NAN,

'X-Inf' => INF,

'X-Negative-Inf' => -INF,

'X-Multiple' => [NAN, INF, -INF],

])->wait();

$this->assertSame(['NAN'], $response->getHeader('X-Nan'));

$this->assertSame(['INF'], $response->getHeader('X-Inf'));

$this->assertSame(['-INF'], $response->getHeader('X-Negative-Inf'));

$this->assertSame(['NAN', 'INF', '-INF'], $response->getHeader('X-Multiple'));

}

#[DataProvider('invalidFakeResponseHeaderValuesProvider')]

public function testInvalidFakeResponseHeaderValuesAreRejected($value)

{

$this->expectExceptionObject(new InvalidArgumentException('HTTP fake response header values must be scalar, null, Laravel Stringable, or arrays of scalar, null, or Laravel Stringable values.'));

$this->factory::response('OK', 200, ['X-Test' => $value]);

}

public function testStatusCodeShorthand()

{

$this->factory->fake([

'forge.laravel.com' => 204,

'vapor.laravel.com' => HttpResponse::HTTP_CREATED,

]);

$response = $this->factory->post('http://forge.laravel.com');

$this->assertTrue($response->noContent());

$response = $this->factory->post('http://vapor.laravel.com');

$this->assertTrue($response->created());

}

public function testBodyShorthands()

{

$this->factory->fake([

'google.com' => 'Hello World',

'github.com' => ['foo' => 'bar'],

]);

$response = $this->factory->get('http://google.com');

$this->assertTrue($response->ok());

$this->assertSame('Hello World', $response->body());

$response = $this->factory->post('http://github.com');

$this->assertTrue($response->ok());

$this->assertSame('{"foo":"bar"}', $response->body());

$this->assertSame(['foo' => 'bar'], $response->json());

}

public function testFakeResponseSupportsPsr7StreamBody()

{

$stream = Utils::streamFor('Hello World');

$response = $this->factory::response($stream)->wait();

$this->assertSame($stream, $response->getBody());

$this->assertSame('Hello World', (string) $response->getBody());

}

public function testFakeResponseSupportsResourceBody()

{

$resource = fopen('php://temp', 'w+');

fwrite($resource, 'Hello World');

rewind($resource);

$response = $this->factory::response($resource)->wait();

$this->assertSame('Hello World', (string) $response->getBody());

}

public function testFakeResponseRejectsUnsupportedBody()

{

$this->expectExceptionObject(new InvalidArgumentException('HTTP fake response body must be a string, array, stream resource, Psr\Http\Message\StreamInterface, or null.'));

$this->factory::response(new stdClass);

}

public function testFakeResponseRejectsNonStreamResourceBody()

{

$this->expectExceptionObject(new InvalidArgumentException('HTTP fake response body must be a string, array, stream resource, Psr\Http\Message\StreamInterface, or null.'));

$this->factory::response(stream_context_create());

}

public function testAcceptedRequest()

{

$this->factory->fake([

'vapor.laravel.com' => $this->factory::response('', HttpResponse::HTTP_ACCEPTED),

'forge.laravel.com' => $this->factory::response('', HttpResponse::HTTP_OK),

]);

$response = $this->factory->post('http://vapor.laravel.com');

$this->assertTrue($response->accepted());

$response = $this->factory->post('http://forge.laravel.com');

$this->assertFalse($response->accepted());

}

public function testMovedPermanentlyRequest()

{

$this->factory->fake([

'vapor.laravel.com' => $this->factory::response('', HttpResponse::HTTP_MOVED_PERMANENTLY),

'forge.laravel.com' => $this->factory::response('', HttpResponse::HTTP_OK),

]);

$response = $this->factory->post('http://vapor.laravel.com');

$this->assertTrue($response->movedPermanently());

$response = $this->factory->post('http://forge.laravel.com');

$this->assertFalse($response->movedPermanently());

}

public function testNoContentRequest()

{

$this->factory->fake([

'vapor.laravel.com' => $this->factory::response('', HttpResponse::HTTP_NO_CONTENT),

'forge.laravel.com' => $this->factory::response('', HttpResponse::HTTP_OK),

]);

$response = $this->factory->post('http://vapor.laravel.com');

$this->assertTrue($response->noContent());

$response = $this->factory->post('http://forge.laravel.com');

$this->assertFalse($response->noContent());

}

public function testFoundRequest()

{

$this->factory->fake([

'vapor.laravel.com' => $this->factory::response('', HttpResponse::HTTP_FOUND),

'forge.laravel.com' => $this->factory::response('', HttpResponse::HTTP_OK),

]);

$response = $this->factory->post('http://vapor.laravel.com');

$this->assertTrue($response->found());

$response = $this->factory->post('http://forge.laravel.com');

$this->assertFalse($response->found());

}

public function testNotModifiedRequest(): void

{

$this->factory->fake([

'vapor.laravel.com' => $this->factory::response('', HttpResponse::HTTP_NOT_MODIFIED),

'forge.laravel.com' => $this->factory::response('', HttpResponse::HTTP_OK),

]);

$response = $this->factory->post('https://vapor.laravel.com');

$this->assertTrue($response->notModified());

$response = $this->factory->post('https://forge.laravel.com');

$this->assertFalse($response->notModified());

}

public function testBadRequestRequest()

{

$this->factory->fake([

'vapor.laravel.com' => $this->factory::response('', HttpResponse::HTTP_BAD_REQUEST),

'forge.laravel.com' => $this->factory::response('', HttpResponse::HTTP_OK),

]);

$response = $this->factory->post('http://vapor.laravel.com');

$this->assertTrue($response->badRequest());

$response = $this->factory->post('http://forge.laravel.com');

$this->assertFalse($response->badRequest());

}

public function testPaymentRequiredRequest()

{

$this->factory->fake([

'vapor.laravel.com' => $this->factory::response('', HttpResponse::HTTP_PAYMENT_REQUIRED),

'forge.laravel.com' => $this->factory::response('', HttpResponse::HTTP_OK),

]);

$response = $this->factory->post('http://vapor.laravel.com');

$this->assertTrue($response->paymentRequired());

$response = $this->factory->post('http://forge.laravel.com');

$this->assertFalse($response->paymentRequired());

}

public function testRequestTimeoutRequest()

{

$this->factory->fake([

'vapor.laravel.com' => $this->factory::response('', HttpResponse::HTTP_REQUEST_TIMEOUT),

'forge.laravel.com' => $this->factory::response('', HttpResponse::HTTP_OK),

]);

$response = $this->factory->post('http://vapor.laravel.com');

$this->assertTrue($response->requestTimeout());

$response = $this->factory->post('http://forge.laravel.com');

$this->assertFalse($response->requestTimeout());

}

public function testConflictResponseRequest()

{

$this->factory->fake([

'vapor.laravel.com' => $this->factory::response('', HttpResponse::HTTP_CONFLICT),

'forge.laravel.com' => $this->factory::response('', HttpResponse::HTTP_OK),

]);

$response = $this->factory->post('http://vapor.laravel.com');

$this->assertTrue($response->conflict());

$response = $this->factory->post('http://forge.laravel.com');

$this->assertFalse($response->conflict());

}

public function testUnprocessableContentRequest()

{

$this->factory->fake([

'vapor.laravel.com' => $this->factory::response('', HttpResponse::HTTP_UNPROCESSABLE_ENTITY),

'forge.laravel.com' => $this->factory::response('', HttpResponse::HTTP_OK),

]);

$response = $this->factory->post('http://vapor.laravel.com');

$this->assertTrue($response->unprocessableContent());

$response = $this->factory->post('http://forge.laravel.com');

$this->assertFalse($response->unprocessableContent());

}

public function testUnprocessableEntityRequest()

{

$this->factory->fake([

'vapor.laravel.com' => $this->factory::response('', HttpResponse::HTTP_UNPROCESSABLE_ENTITY),

'forge.laravel.com' => $this->factory::response('', HttpResponse::HTTP_OK),

]);

$response = $this->factory->post('http://vapor.laravel.com');

$this->assertTrue($response->unprocessableEntity());

$response = $this->factory->post('http://forge.laravel.com');

$this->assertFalse($response->unprocessableEntity());

}

public function testTooManyRequestsRequest()

{

$this->factory->fake([

'vapor.laravel.com' => $this->factory::response('', HttpResponse::HTTP_TOO_MANY_REQUESTS),

'forge.laravel.com' => $this->factory::response('', HttpResponse::HTTP_OK),

]);

$response = $this->factory->post('http://vapor.laravel.com');

$this->assertTrue($response->tooManyRequests());

$response = $this->factory->post('http://forge.laravel.com');

$this->assertFalse($response->tooManyRequests());

}

public function testUnauthorizedRequest()

{

$this->factory->fake([

'laravel.com' => $this->factory::response('', 401),

]);

$response = $this->factory->post('http://laravel.com');

$this->assertTrue($response->unauthorized());

}

public function testForbiddenRequest()

{

$this->factory->fake([

'laravel.com' => $this->factory::response('', 403),

]);

$response = $this->factory->post('http://laravel.com');

$this->assertTrue($response->forbidden());

}

public function testNotFoundResponse()

{

$this->factory->fake([

'laravel.com' => $this->factory::response('', 404),

]);

$response = $this->factory->post('http://laravel.com');

$this->assertTrue($response->notFound());

}

public function testResponseBodyCasting()

{

$this->factory->fake([

'*' => ['result' => ['foo' => 'bar']],

]);

$response = $this->factory->get('http://foo.com/api');

$this->assertSame('{"result":{"foo":"bar"}}', $response->body());

$this->assertSame('{"result":{"foo":"bar"}}', (string) $response);

$this->assertIsArray($response->json());

$this->assertSame(['foo' => 'bar'], $response->json()['result']);

$this->assertSame(['foo' => 'bar'], $response->json('result'));

$this->assertSame('bar', $response->json('result.foo'));

$this->assertSame('default', $response->json('missing_key', 'default'));

$this->assertSame(['foo' => 'bar'], $response['result']);

}

public function testResponseObjectAsArray()

{

$this->factory->fake([

'*' => [['foo' => 'bar'], ['bar' => 'foo']],

]);

$response = $this->factory->get('http://foo.com/api');

$this->assertSame('[{"foo":"bar"},{"bar":"foo"}]', $response->body());

$this->assertSame('[{"foo":"bar"},{"bar":"foo"}]', (string) $response);

$this->assertIsArray($response->object());

$this->assertSame('bar', $response->object()[0]->foo);

}

public function testResponseObjectAsObject()

{

$this->factory->fake([

'*' => ['result' => ['foo' => 'bar']],

]);

$response = $this->factory->get('http://foo.com/api');

$this->assertIsObject($response->object());

$this->assertSame('bar', $response->object()->result->foo);

}

public function testResponseObjectIsTappable()

{

$bar = null;

$this->factory->fake([

'*' => ['result' => ['foo' => 'bar']],

]);

$this->factory->get('http://foo.com/api')

->tap(function (Response $response) use (&$bar) {

$bar = $response['result']['foo'];

});

$this->assertSame('bar', $bar);

}

public function testResponseObjectIsMacroable()

{

Response::macro('movieFields', function () {

return $this->collect()

->mapWithKeys(fn ($field, $key) => [strtolower($key) => $field])

->toArray();

});

$response = $this->factory->fake([

'*' => [

'Title' => 'The Godfather',

'Year' => 1972,

'Rated' => 'R',

'Runtime' => '175 min',

'Director' => 'Francis Ford Coppola',

],

]);

$response = $this->factory->get('http://www.omdbapi.com/?apikey=test_api_key&i=test_imdb_id');

$this->assertIsArray($response->movieFields());

$this->assertSame([

'title' => 'The Godfather',

'year' => 1972,

'rated' => 'R',

'runtime' => '175 min',

'director' => 'Francis Ford Coppola',

], $response->movieFields());

}

public function testResponseCanBeReturnedAsResource()

{

$this->factory->fake([

'*' => ['result' => ['foo' => 'bar']],

]);

$response = $this->factory->get('http://foo.com/api');

$this->assertIsResource($response->resource());

$this->assertSame('{"result":{"foo":"bar"}}', stream_get_contents($response->resource()));

}

public function testResponseCanBeReturnedAsCollection()

{

$this->factory->fake([

'*' => ['result' => ['foo' => 'bar']],

]);

$response = $this->factory->get('http://foo.com/api');

$this->assertInstanceOf(Collection::class, $response->collect());

$this->assertEquals(collect(['result' => ['foo' => 'bar']]), $response->collect());

$this->assertEquals(collect(['foo' => 'bar']), $response->collect('result'));

$this->assertEquals(collect(['bar']), $response->collect('result.foo'));

$this->assertEquals(collect(), $response->collect('missing_key'));

}

public function testResponseCanBeReturnedAsFluent()

{

$this->factory->fake([

'*' => ['result' => ['foo' => 'bar']],

]);

$response = $this->factory->get('http://foo.com/api');

$this->assertInstanceOf(Fluent::class, $response->fluent());

$this->assertEquals(new Fluent(['result' => ['foo' => 'bar']]), $response->fluent());

$this->assertEquals(new Fluent(['foo' => 'bar']), $response->fluent('result'));

$this->assertEquals(new Fluent(['bar']), $response->fluent('result.foo'));

$this->assertEquals(new Fluent([]), $response->fluent('missing_key'));

}

public function testSendRequestBodyAsJsonByDefault()

{

$body = '{"test":"phpunit"}';

$fakeRequest = function (Request $request) use ($body) {

$this->assertSame($body, $request->body());

$this->assertContains('application/json', $request->header('Content-Type'));

return ['my' => 'response'];

};

$this->factory->fake($fakeRequest);

$this->factory->withBody($body)->send('get', 'http://foo.com/api');

}

public function testSendRequestBodyWithManyAmpersands()

{

$body = str_repeat('A thousand &. ', 1000);

$fakeRequest = function (Request $request) use ($body) {

$this->assertSame($body, $request->body());

$this->assertContains('text/plain', $request->header('Content-Type'));

return ['my' => 'response'];

};

$this->factory->fake($fakeRequest);

$this->factory->withBody($body, 'text/plain')->send('post', 'http://foo.com/api');

}

public function testSendStreamRequestBody()

{

$string = 'Look at me, i am a stream!!';

$resource = fopen('php://temp', 'w');

fwrite($resource, $string);

rewind($resource);

$body = Utils::streamFor($resource);

$fakeRequest = function (Request $request) use ($string) {

$this->assertSame($string, $request->body());

$this->assertContains('text/plain', $request->header('Content-Type'));

return ['my' => 'response'];

};

$this->factory->fake($fakeRequest);

$this->factory->withBody($body, 'text/plain')->send('post', 'http://foo.com/api');

}

public function testUrlsCanBeStubbedByPath()

{

$this->factory->fake([

'foo.com/*' => ['page' => 'foo'],

'bar.com/*' => ['page' => 'bar'],

'*' => ['page' => 'fallback'],

]);

$fooResponse = $this->factory->post('http://foo.com/test');

$barResponse = $this->factory->post('http://bar.com/test');

$fallbackResponse = $this->factory->post('http://fallback.com/test');

$this->assertSame('foo', $fooResponse['page']);

$this->assertSame('bar', $barResponse['page']);

$this->assertSame('fallback', $fallbackResponse['page']);

$this->factory->assertSent(function (Request $request) {

return $request->url() === 'http://foo.com/test' &&

$request->hasHeader('Content-Type', 'application/json');

});

}

public function testCanSendJsonData()

{

$this->factory->fake();

$this->factory->withHeaders([

'X-Test-Header' => 'foo',

'X-Test-ArrayHeader' => ['bar', 'baz'],

])->post('http://foo.com/json', [

'name' => 'Taylor',

]);

$this->factory->assertSent(function (Request $request) {

return $request->url() === 'http://foo.com/json' &&

$request->hasHeader('Content-Type', 'application/json') &&

$request->hasHeader('X-Test-Header', 'foo') &&

$request->hasHeader('X-Test-ArrayHeader', ['bar', 'baz']) &&

$request['name'] === 'Taylor';

});

}

public function testCanSendFormData()

{

$this->factory->fake();

$this->factory->asForm()->post('http://foo.com/form', [

'name' => 'Taylor',

'title' => 'Laravel Developer',

]);

$this->factory->assertSent(function (Request $request) {

return $request->url() === 'http://foo.com/form' &&

$request->hasHeader('Content-Type', 'application/x-www-form-urlencoded') &&

$request['name'] === 'Taylor';

});

}

public function testCanSendJsonDataWithQueryMethod()

{

$this->factory->fake();

$this->factory->query('http://foo.com/search', [

'filter' => 'active',

]);

$this->factory->assertSent(function (Request $request) {

return $request->url() === 'http://foo.com/search' &&

$request->method() === 'QUERY' &&

$request->hasHeader('Content-Type', 'application/json') &&

$request['filter'] === 'active';

});

}

public function testCanSendFormDataWithQueryMethod()

{

$this->factory->fake();

$this->factory->asForm()->query('http://foo.com/search', [

'filter' => 'active',

]);

$this->factory->assertSent(function (Request $request) {

return $request->url() === 'http://foo.com/search' &&

$request->method() === 'QUERY' &&

$request->hasHeader('Content-Type', 'application/x-www-form-urlencoded') &&

$request['filter'] === 'active';

});

}

public function testQueryParametersNormalizeNonFiniteFloats()

{

$this->factory->fake();

$this->factory->get('https://laravel.com/search', [

'nan' => NAN,

'inf' => INF,

'negative_inf' => -INF,

'nested' => ['value' => NAN],

]);

$this->factory->assertSent(function (Request $request) {

return $request->url() === 'https://laravel.com/search?nan=NAN&inf=INF&negative_inf=-INF&nested%5Bvalue%5D=NAN';

});

}

public function testFormParamsNormalizeNonFiniteFloats()

{

$this->factory->fake();

$this->factory->asForm()->post('http://foo.com/form', [

'nan' => NAN,

'inf' => INF,

'negative_inf' => -INF,

'nested' => ['value' => NAN],

]);

$this->factory->assertSent(function (Request $request) {

return $request->url() === 'http://foo.com/form'

&& $request->body() === 'nan=NAN&inf=INF&negative_inf=-INF&nested%5Bvalue%5D=NAN';

});

}

#[DataProvider('methodsReceivingArrayableDataProvider')]

public function testCanSendArrayableFormData(string $method)

{

$this->factory->fake();

$this->factory->asForm()->{$method}('http://foo.com/form', new Fluent([

'name' => 'Taylor',

'title' => 'Laravel Developer',

]));

$this->factory->assertSent(function (Request $request) {

return $request->url() === 'http://foo.com/form' &&

$request->hasHeader('Content-Type', 'application/x-www-form-urlencoded') &&

$request['name'] === 'Taylor';

});

}

#[DataProvider('methodsReceivingArrayableDataProvider')]

public function testCanSendJsonSerializableData(string $method)

{

$this->factory->fake();

$this->factory->asJson()->{$method}('http://foo.com/form', new class implements JsonSerializable

{

public function jsonSerialize(): mixed

{

return [

'name' => 'Taylor',

'title' => 'Laravel Developer',

];

}

});

$this->factory->assertSent(function (Request $request) {

return $request->url() === 'http://foo.com/form' &&

$request->hasHeader('Content-Type', 'application/json') &&

$request['name'] === 'Taylor';

});

}

#[DataProvider('methodsReceivingArrayableDataProvider')]

public function testPrefersJsonSerializableOverArrayableData(string $method)

{

$this->factory->fake();

$this->factory->asJson()->{$method}('http://foo.com/form', new class implements JsonSerializable, Arrayable

{

public function jsonSerialize(): mixed

{

return [

'attributes' => (object) [],

];

}

public function toArray(): array

{

return [

'attributes' => [],

];

}

});

$this->factory->assertSent(function (Request $request) {

return $request->url() === 'http://foo.com/form' &&

$request->hasHeader('Content-Type', 'application/json') &&

$request->body() === '{"attributes":{}}';

});

}

public function testCanSendJsonDataWithStringable()

{

$this->factory->fake();

$this->factory->withHeaders([

'X-Test-Header' => 'foo',

'X-Test-ArrayHeader' => ['bar', 'baz'],

])->post('http://foo.com/json', [

'name' => new Stringable('Taylor'),

]);

$this->factory->assertSent(function (Request $request) {

return $request->url() === 'http://foo.com/json' &&

$request->hasHeader('Content-Type', 'application/json') &&

$request->hasHeader('X-Test-Header', 'foo') &&

$request->hasHeader('X-Test-ArrayHeader', ['bar', 'baz']) &&

$request['name'] === 'Taylor';

});

}

public function testHeaderValuesAreSerialized()

{

$this->factory->fake();

$this->factory->withHeaders([

'X-Int' => 123,

'X-Float' => 1.5,

'X-Null' => null,

'X-True' => true,

'X-False' => false,

'X-Nan' => NAN,

'X-Inf' => INF,

'X-Negative-Inf' => -INF,

'X-Laravel-Stringable' => new Stringable('laravel stringable'),

'X-Multiple' => ['first', 123, true, false, null, NAN, INF, -INF],

'X-Empty' => [],

])->post('http://foo.com/json');

$this->factory->assertSent(function (Request $request) {

return $request->hasHeader('X-Int', '123')

&& $request->hasHeader('X-Float', '1.5')

&& $request->hasHeader('X-Null', '')

&& $request->hasHeader('X-True', '1')

&& $request->hasHeader('X-False', '')

&& $request->hasHeader('X-Nan', 'NAN')

&& $request->hasHeader('X-Inf', 'INF')

&& $request->hasHeader('X-Negative-Inf', '-INF')

&& $request->hasHeader('X-Laravel-Stringable', 'laravel stringable')

&& $request->hasHeader('X-Multiple', ['first', '123', '1', '', '', 'NAN', 'INF', '-INF'])

&& $request->hasHeader('X-Empty', '');

});

}

#[DataProvider('invalidHeaderValuesProvider')]

public function testInvalidHeaderValuesAreRejected($value)

{

$this->factory->fake();

$this->expectExceptionObject(new InvalidArgumentException('HTTP header values must be scalar, null, Laravel Stringable, or arrays of scalar, null, or Laravel Stringable values.'));

$this->factory->withHeaders(['X-Test' => $value])->post('http://foo.com/json');

}

public function testHeaderValuesProvidedThroughOptionsAreSerialized()

{

$this->factory->fake();

$this->factory->withOptions([

'headers' => ['X-Test' => 123, 'X-Null' => null, 'X-Nan' => NAN],

])->post('http://foo.com/json');

$this->factory->assertSent(function (Request $request) {

return $request->hasHeader('X-Test', '123')

&& $request->hasHeader('X-Null', '')

&& $request->hasHeader('X-Nan', 'NAN');

});

}

public function testRequestHeadersAreCheckedCaseInsensitively()

{

$this->factory->fake();

$this->factory->withHeaders([

'foo' => 'Bar',

])->post('http://foo.com/json');

$this->factory->assertSent(function (Request $request) {

return $request->hasHeader('Foo')

&& $request->hasHeader('Foo', 'Bar')

&& $request->header('Foo') === ['Bar'];

});

}

public function testContentTypeHeadersAreCheckedCaseInsensitively()

{

$this->factory->fake();

$this->factory->send('POST', 'http://foo.com/json', [

'headers' => ['content-type' => 'application/json'],

'body' => '{"name":"Taylor"}',

]);

$this->factory->assertSent(function (Request $request) {

return $request->hasHeader('Content-Type')

&& $request->header('Content-Type') === ['application/json']

&& $request->isJson();

});

}

public function testCanSendFormDataWithStringable()

{

$this->factory->fake();

$this->factory->asForm()->post('http://foo.com/form', [

'name' => new Stringable('Taylor'),

'title' => 'Laravel Developer',

]);

$this->factory->assertSent(function (Request $request) {

return $request->url() === 'http://foo.com/form' &&

$request->hasHeader('Content-Type', 'application/x-www-form-urlencoded') &&

$request['name'] === 'Taylor';

});

}

public function testCanSendFormDataWithStringableInArrays()

{

$this->factory->fake();

$this->factory->asForm()->post('http://foo.com/form', [

'posts' => [['title' => new Stringable('Taylor')]],

]);

$this->factory->assertSent(function (Request $request) {

return $request->url() === 'http://foo.com/form' &&

$request->hasHeader('Content-Type', 'application/x-www-form-urlencoded') &&

$request['posts'][0]['title'] === 'Taylor';

});

}

public function testRecordedCallsAreEmptiedWhenFakeIsCalled()

{

$this->factory->fake([

'http://foo.com/*' => ['page' => 'foo'],

]);

$this->factory->get('http://foo.com/test');

$this->factory->assertSent(function (Request $request) {

return $request->url() === 'http://foo.com/test';

});

$this->factory->fake();

$this->factory->assertNothingSent();

}

public function testSpecificRequestIsNotBeingSent()

{

$this->factory->fake();

$this->factory->post('http://foo.com/form', [

'name' => 'Taylor',

]);

$this->factory->assertNotSent(function (Request $request) {

return $request->url() === 'http://foo.com/form' &&