Файл: src/vendor/laravel/framework/src/Illuminate/Foundation/Testing/Concerns/MakesHttpRequests.php
Строк: 647
<?php
namespace IlluminateFoundationTestingConcerns;
use IlluminateSupportArr;
use IlluminateSupportStr;
use IlluminateHttpRequest;
use IlluminateContractsViewView;
use PHPUnit_Framework_Assert as PHPUnit;
use SymfonyComponentHttpFoundationFileUploadedFile as SymfonyUploadedFile;
trait MakesHttpRequests
{
use InteractsWithPages;
/**
* The last response returned by the application.
*
* @var IlluminateHttpResponse
*/
protected $response;
/**
* The current URL being viewed.
*
* @var string
*/
protected $currentUri;
/**
* Additional server variables for the request.
*
* @var array
*/
protected $serverVariables = [];
/**
* Disable middleware for the test.
*
* @return $this
*/
public function withoutMiddleware()
{
$this->app->instance('middleware.disable', true);
return $this;
}
/**
* Visit the given URI with a JSON request.
*
* @param string $method
* @param string $uri
* @param array $data
* @param array $headers
* @return $this
*/
public function json($method, $uri, array $data = [], array $headers = [])
{
$files = $this->extractFilesFromDataArray($data);
$content = json_encode($data);
$headers = array_merge([
'CONTENT_LENGTH' => mb_strlen($content, '8bit'),
'CONTENT_TYPE' => 'application/json',
'Accept' => 'application/json',
], $headers);
$this->call(
$method, $uri, [], [], $files, $this->transformHeadersToServerVars($headers), $content
);
return $this;
}
/**
* Extract the file uploads from the given data array.
*
* @param array $data
* @return array
*/
protected function extractFilesFromDataArray(&$data)
{
$files = [];
foreach ($data as $key => $value) {
if ($value instanceof SymfonyUploadedFile) {
$files[$key] = $value;
unset($data[$key]);
}
}
return $files;
}
/**
* Visit the given URI with a GET request.
*
* @param string $uri
* @param array $headers
* @return $this
*/
public function get($uri, array $headers = [])
{
$server = $this->transformHeadersToServerVars($headers);
$this->call('GET', $uri, [], [], [], $server);
return $this;
}
/**
* Visit the given URI with a POST request.
*
* @param string $uri
* @param array $data
* @param array $headers
* @return $this
*/
public function post($uri, array $data = [], array $headers = [])
{
$server = $this->transformHeadersToServerVars($headers);
$this->call('POST', $uri, $data, [], [], $server);
return $this;
}
/**
* Visit the given URI with a PUT request.
*
* @param string $uri
* @param array $data
* @param array $headers
* @return $this
*/
public function put($uri, array $data = [], array $headers = [])
{
$server = $this->transformHeadersToServerVars($headers);
$this->call('PUT', $uri, $data, [], [], $server);
return $this;
}
/**
* Visit the given URI with a PATCH request.
*
* @param string $uri
* @param array $data
* @param array $headers
* @return $this
*/
public function patch($uri, array $data = [], array $headers = [])
{
$server = $this->transformHeadersToServerVars($headers);
$this->call('PATCH', $uri, $data, [], [], $server);
return $this;
}
/**
* Visit the given URI with a DELETE request.
*
* @param string $uri
* @param array $data
* @param array $headers
* @return $this
*/
public function delete($uri, array $data = [], array $headers = [])
{
$server = $this->transformHeadersToServerVars($headers);
$this->call('DELETE', $uri, $data, [], [], $server);
return $this;
}
/**
* Send the given request through the application.
*
* This method allows you to fully customize the entire Request object.
*
* @param IlluminateHttpRequest $request
* @return $this
*/
public function handle(Request $request)
{
$this->currentUri = $request->fullUrl();
$this->response = $this->app->prepareResponse($this->app->handle($request));
return $this;
}
/**
* Assert that the response contains JSON.
*
* @param array|null $data
* @return $this
*/
protected function shouldReturnJson(array $data = null)
{
return $this->receiveJson($data);
}
/**
* Assert that the response contains JSON.
*
* @param array|null $data
* @return $this|null
*/
protected function receiveJson($data = null)
{
return $this->seeJson($data);
}
/**
* Assert that the response contains an exact JSON array.
*
* @param array $data
* @return $this
*/
public function seeJsonEquals(array $data)
{
$actual = json_encode(Arr::sortRecursive(
json_decode($this->response->getContent(), true)
));
$this->assertEquals(json_encode(Arr::sortRecursive($data)), $actual);
return $this;
}
/**
* Assert that the response contains JSON.
*
* @param array|null $data
* @param bool $negate
* @return $this
*/
public function seeJson(array $data = null, $negate = false)
{
if (is_null($data)) {
$this->assertJson(
$this->response->getContent(), "JSON was not returned from [{$this->currentUri}]."
);
return $this;
}
return $this->seeJsonContains($data, $negate);
}
/**
* Assert that the response doesn't contain JSON.
*
* @param array|null $data
* @return $this
*/
public function dontSeeJson(array $data = null)
{
return $this->seeJson($data, true);
}
/**
* Assert that the JSON response has a given structure.
*
* @param array|null $structure
* @param array|null $responseData
* @return $this
*/
public function seeJsonStructure(array $structure = null, $responseData = null)
{
if (is_null($structure)) {
return $this->seeJson();
}
if (! $responseData) {
$responseData = json_decode($this->response->getContent(), true);
}
foreach ($structure as $key => $value) {
if (is_array($value) && $key === '*') {
$this->assertInternalType('array', $responseData);
foreach ($responseData as $responseDataItem) {
$this->seeJsonStructure($structure['*'], $responseDataItem);
}
} elseif (is_array($value)) {
$this->assertArrayHasKey($key, $responseData);
$this->seeJsonStructure($structure[$key], $responseData[$key]);
} else {
$this->assertArrayHasKey($value, $responseData);
}
}
return $this;
}
/**
* Assert that the response contains the given JSON.
*
* @param array $data
* @param bool $negate
* @return $this
*/
protected function seeJsonContains(array $data, $negate = false)
{
$method = $negate ? 'assertFalse' : 'assertTrue';
$actual = json_encode(Arr::sortRecursive(
(array) $this->decodeResponseJson()
));
foreach (Arr::sortRecursive($data) as $key => $value) {
$expected = $this->formatToExpectedJson($key, $value);
$this->{$method}(
Str::contains($actual, $expected),
($negate ? 'Found unexpected' : 'Unable to find')." JSON fragment [{$expected}] within [{$actual}]."
);
}
return $this;
}
/**
* Assert that the response is a superset of the given JSON.
*
* @param array $data
* @return $this
*/
protected function seeJsonSubset(array $data)
{
$this->assertArraySubset($data, $this->decodeResponseJson());
return $this;
}
/**
* Validate and return the decoded response JSON.
*
* @return array
*/
protected function decodeResponseJson()
{
$decodedResponse = json_decode($this->response->getContent(), true);
if (is_null($decodedResponse) || $decodedResponse === false) {
$this->fail('Invalid JSON was returned from the route. Perhaps an exception was thrown?');
}
return $decodedResponse;
}
/**
* Format the given key and value into a JSON string for expectation checks.
*
* @param string $key
* @param mixed $value
* @return string
*/
protected function formatToExpectedJson($key, $value)
{
$expected = json_encode([$key => $value]);
if (Str::startsWith($expected, '{')) {
$expected = substr($expected, 1);
}
if (Str::endsWith($expected, '}')) {
$expected = substr($expected, 0, -1);
}
return $expected;
}
/**
* Asserts that the status code of the response matches the given code.
*
* @param int $status
* @return $this
*/
protected function seeStatusCode($status)
{
$this->assertEquals($status, $this->response->getStatusCode());
return $this;
}
/**
* Asserts that the response contains the given header and equals the optional value.
*
* @param string $headerName
* @param mixed $value
* @return $this
*/
protected function seeHeader($headerName, $value = null)
{
$headers = $this->response->headers;
$this->assertTrue($headers->has($headerName), "Header [{$headerName}] not present on response.");
if (! is_null($value)) {
$this->assertEquals(
$headers->get($headerName), $value,
"Header [{$headerName}] was found, but value [{$headers->get($headerName)}] does not match [{$value}]."
);
}
return $this;
}
/**
* Asserts that the response contains the given cookie and equals the optional value.
*
* @param string $cookieName
* @param mixed $value
* @return $this
*/
protected function seePlainCookie($cookieName, $value = null)
{
return $this->seeCookie($cookieName, $value, false);
}
/**
* Asserts that the response contains the given cookie and equals the optional value.
*
* @param string $cookieName
* @param mixed $value
* @param bool $encrypted
* @return $this
*/
protected function seeCookie($cookieName, $value = null, $encrypted = true)
{
$headers = $this->response->headers;
$exist = false;
foreach ($headers->getCookies() as $cookie) {
if ($cookie->getName() === $cookieName) {
$exist = true;
break;
}
}
$this->assertTrue($exist, "Cookie [{$cookieName}] not present on response.");
if (! $exist || is_null($value)) {
return $this;
}
$cookieValue = $cookie->getValue();
$actual = $encrypted
? $this->app['encrypter']->decrypt($cookieValue) : $cookieValue;
return $this->assertEquals(
$actual, $value,
"Cookie [{$cookieName}] was found, but value [{$actual}] does not match [{$value}]."
);
}
/**
* Define a set of server variables to be sent with the requests.
*
* @param array $server
* @return $this
*/
protected function withServerVariables(array $server)
{
$this->serverVariables = $server;
return $this;
}
/**
* Call the given URI and return the Response.
*
* @param string $method
* @param string $uri
* @param array $parameters
* @param array $cookies
* @param array $files
* @param array $server
* @param string $content
* @return IlluminateHttpResponse
*/
public function call($method, $uri, $parameters = [], $cookies = [], $files = [], $server = [], $content = null)
{
$kernel = $this->app->make('IlluminateContractsHttpKernel');
$this->currentUri = $this->prepareUrlForRequest($uri);
$request = Request::create(
$this->currentUri, $method, $parameters,
$cookies, $files, array_replace($this->serverVariables, $server), $content
);
$response = $kernel->handle($request);
$kernel->terminate($request, $response);
return $this->response = $response;
}
/**
* Call the given HTTPS URI and return the Response.
*
* @param string $method
* @param string $uri
* @param array $parameters
* @param array $cookies
* @param array $files
* @param array $server
* @param string $content
* @return IlluminateHttpResponse
*/
public function callSecure($method, $uri, $parameters = [], $cookies = [], $files = [], $server = [], $content = null)
{
$uri = $this->app['url']->secure(ltrim($uri, '/'));
return $this->response = $this->call($method, $uri, $parameters, $cookies, $files, $server, $content);
}
/**
* Call a controller action and return the Response.
*
* @param string $method
* @param string $action
* @param array $wildcards
* @param array $parameters
* @param array $cookies
* @param array $files
* @param array $server
* @param string $content
* @return IlluminateHttpResponse
*/
public function action($method, $action, $wildcards = [], $parameters = [], $cookies = [], $files = [], $server = [], $content = null)
{
$uri = $this->app['url']->action($action, $wildcards, true);
return $this->response = $this->call($method, $uri, $parameters, $cookies, $files, $server, $content);
}
/**
* Call a named route and return the Response.
*
* @param string $method
* @param string $name
* @param array $routeParameters
* @param array $parameters
* @param array $cookies
* @param array $files
* @param array $server
* @param string $content
* @return IlluminateHttpResponse
*/
public function route($method, $name, $routeParameters = [], $parameters = [], $cookies = [], $files = [], $server = [], $content = null)
{
$uri = $this->app['url']->route($name, $routeParameters);
return $this->response = $this->call($method, $uri, $parameters, $cookies, $files, $server, $content);
}
/**
* Turn the given URI into a fully qualified URL.
*
* @param string $uri
* @return string
*/
protected function prepareUrlForRequest($uri)
{
if (Str::startsWith($uri, '/')) {
$uri = substr($uri, 1);
}
if (! Str::startsWith($uri, 'http')) {
$uri = $this->baseUrl.'/'.$uri;
}
return trim($uri, '/');
}
/**
* Transform headers array to array of $_SERVER vars with HTTP_* format.
*
* @param array $headers
* @return array
*/
protected function transformHeadersToServerVars(array $headers)
{
$server = [];
$prefix = 'HTTP_';
foreach ($headers as $name => $value) {
$name = strtr(strtoupper($name), '-', '_');
if (! Str::startsWith($name, $prefix) && $name != 'CONTENT_TYPE') {
$name = $prefix.$name;
}
$server[$name] = $value;
}
return $server;
}
/**
* Assert that the client response has an OK status code.
*
* @return void
*/
public function assertResponseOk()
{
$actual = $this->response->getStatusCode();
return PHPUnit::assertTrue($this->response->isOk(), "Expected status code 200, got {$actual}.");
}
/**
* Assert that the client response has a given code.
*
* @param int $code
* @return void
*/
public function assertResponseStatus($code)
{
$actual = $this->response->getStatusCode();
return PHPUnit::assertEquals($code, $this->response->getStatusCode(), "Expected status code {$code}, got {$actual}.");
}
/**
* Assert that the response view has a given piece of bound data.
*
* @param string|array $key
* @param mixed $value
* @return void
*/
public function assertViewHas($key, $value = null)
{
if (is_array($key)) {
return $this->assertViewHasAll($key);
}
if (! isset($this->response->original) || ! $this->response->original instanceof View) {
return PHPUnit::assertTrue(false, 'The response was not a view.');
}
if (is_null($value)) {
PHPUnit::assertArrayHasKey($key, $this->response->original->getData());
} else {
PHPUnit::assertEquals($value, $this->response->original->$key);
}
}
/**
* Assert that the view has a given list of bound data.
*
* @param array $bindings
* @return void
*/
public function assertViewHasAll(array $bindings)
{
foreach ($bindings as $key => $value) {
if (is_int($key)) {
$this->assertViewHas($value);
} else {
$this->assertViewHas($key, $value);
}
}
}
/**
* Assert that the response view is missing a piece of bound data.
*
* @param string $key
* @return void
*/
public function assertViewMissing($key)
{
if (! isset($this->response->original) || ! $this->response->original instanceof View) {
return PHPUnit::assertTrue(false, 'The response was not a view.');
}
PHPUnit::assertArrayNotHasKey($key, $this->response->original->getData());
}
/**
* Assert whether the client was redirected to a given URI.
*
* @param string $uri
* @param array $with
* @return void
*/
public function assertRedirectedTo($uri, $with = [])
{
PHPUnit::assertInstanceOf('IlluminateHttpRedirectResponse', $this->response);
PHPUnit::assertEquals($this->app['url']->to($uri), $this->response->headers->get('Location'));
$this->assertSessionHasAll($with);
}
/**
* Assert whether the client was redirected to a given route.
*
* @param string $name
* @param array $parameters
* @param array $with
* @return void
*/
public function assertRedirectedToRoute($name, $parameters = [], $with = [])
{
$this->assertRedirectedTo($this->app['url']->route($name, $parameters), $with);
}
/**
* Assert whether the client was redirected to a given action.
*
* @param string $name
* @param array $parameters
* @param array $with
* @return void
*/
public function assertRedirectedToAction($name, $parameters = [], $with = [])
{
$this->assertRedirectedTo($this->app['url']->action($name, $parameters), $with);
}
/**
* Dump the content from the last response.
*
* @return void
*/
public function dump()
{
$content = $this->response->getContent();
$json = json_decode($content);
if (json_last_error() === JSON_ERROR_NONE) {
$content = $json;
}
dd($content);
}
}