Current File : /var/www/html/digiprint/vendor/laravel/framework/src/Illuminate/Foundation/Testing/TestResponse.php
<?php
namespace Illuminate\Foundation\Testing;
use Closure;
use Illuminate\Support\Arr;
use Illuminate\Support\Str;
use Illuminate\Contracts\View\View;
use Illuminate\Support\Traits\Macroable;
use PHPUnit\Framework\Assert as PHPUnit;
use Symfony\Component\HttpFoundation\Cookie;
class TestResponse
{
use Macroable {
__call as macroCall;
}
/**
* The response to delegate to.
*
* @var \Illuminate\Http\Response
*/
public $baseResponse;
/**
* Create a new test response instance.
*
* @param \Illuminate\Http\Response $response
* @return void
*/
public function __construct($response)
{
$this->baseResponse = $response;
}
/**
* Create a new TestResponse from another response.
*
* @param \Illuminate\Http\Response $response
* @return static
*/
public static function fromBaseResponse($response)
{
return new static($response);
}
/**
* Assert that the response has a successful status code.
*
* @return $this
*/
public function assertSuccessful()
{
PHPUnit::assertTrue(
$this->isSuccessful(),
'Response status code ['.$this->getStatusCode().'] is not a successful status code.'
);
return $this;
}
/**
* Assert that the response has the given status code.
*
* @param int $status
* @return $this
*/
public function assertStatus($status)
{
$actual = $this->getStatusCode();
PHPUnit::assertTrue(
$actual === $status,
"Expected status code {$status} but received {$actual}."
);
return $this;
}
/**
* Assert whether the response is redirecting to a given URI.
*
* @param string $uri
* @return $this
*/
public function assertRedirect($uri = null)
{
PHPUnit::assertTrue(
$this->isRedirect(), 'Response status code ['.$this->getStatusCode().'] is not a redirect status code.'
);
if (! is_null($uri)) {
PHPUnit::assertEquals(app('url')->to($uri), $this->headers->get('Location'));
}
return $this;
}
/**
* Asserts that the response contains the given header and equals the optional value.
*
* @param string $headerName
* @param mixed $value
* @return $this
*/
public function assertHeader($headerName, $value = null)
{
PHPUnit::assertTrue(
$this->headers->has($headerName), "Header [{$headerName}] not present on response."
);
$actual = $this->headers->get($headerName);
if (! is_null($value)) {
PHPUnit::assertEquals(
$value, $this->headers->get($headerName),
"Header [{$headerName}] was found, but value [{$actual}] 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
*/
public function assertPlainCookie($cookieName, $value = null)
{
$this->assertCookie($cookieName, $value, false);
return $this;
}
/**
* Asserts that the response contains the given cookie and equals the optional value.
*
* @param string $cookieName
* @param mixed $value
* @param bool $encrypted
* @return $this
*/
public function assertCookie($cookieName, $value = null, $encrypted = true)
{
PHPUnit::assertNotNull(
$cookie = $this->getCookie($cookieName),
"Cookie [{$cookieName}] not present on response."
);
if (! $cookie || is_null($value)) {
return $this;
}
$cookieValue = $cookie->getValue();
$actual = $encrypted
? app('encrypter')->decrypt($cookieValue) : $cookieValue;
PHPUnit::assertEquals(
$value, $actual,
"Cookie [{$cookieName}] was found, but value [{$actual}] does not match [{$value}]."
);
return $this;
}
/**
* Get the given cookie from the response.
*
* @param string $cookieName
* @return \Symfony\Component\HttpFoundation\Cookie|null
*/
protected function getCookie($cookieName)
{
foreach ($this->headers->getCookies() as $cookie) {
if ($cookie->getName() === $cookieName) {
return $cookie;
}
}
}
/**
* Assert that the given string is contained within the response.
*
* @param string $value
* @return $this
*/
public function assertSee($value)
{
PHPUnit::assertContains($value, $this->getContent());
return $this;
}
/**
* Assert that the given string is contained within the response text.
*
* @param string $value
* @return $this
*/
public function assertSeeText($value)
{
PHPUnit::assertContains($value, strip_tags($this->getContent()));
return $this;
}
/**
* Assert that the given string is not contained within the response.
*
* @param string $value
* @return $this
*/
public function assertDontSee($value)
{
PHPUnit::assertNotContains($value, $this->getContent());
return $this;
}
/**
* Assert that the given string is not contained within the response text.
*
* @param string $value
* @return $this
*/
public function assertDontSeeText($value)
{
PHPUnit::assertNotContains($value, strip_tags($this->getContent()));
return $this;
}
/**
* Assert that the response is a superset of the given JSON.
*
* @param array $data
* @return $this
*/
public function assertJson(array $data)
{
PHPUnit::assertArraySubset(
$data, $this->decodeResponseJson(), false, $this->assertJsonMessage($data)
);
return $this;
}
/**
* Get the assertion message for assertJson.
*
* @param array $data
* @return string
*/
protected function assertJsonMessage(array $data)
{
$expected = json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
$actual = json_encode($this->decodeResponseJson(), JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
return 'Unable to find JSON: '.PHP_EOL.PHP_EOL.
"[{$expected}]".PHP_EOL.PHP_EOL.
'within response JSON:'.PHP_EOL.PHP_EOL.
"[{$actual}].".PHP_EOL.PHP_EOL;
}
/**
* Assert that the response has the exact given JSON.
*
* @param array $data
* @return $this
*/
public function assertExactJson(array $data)
{
$actual = json_encode(Arr::sortRecursive(
(array) $this->decodeResponseJson()
));
PHPUnit::assertEquals(json_encode(Arr::sortRecursive($data)), $actual);
return $this;
}
/**
* Assert that the response contains the given JSON fragment.
*
* @param array $data
* @return $this
*/
public function assertJsonFragment(array $data)
{
$actual = json_encode(Arr::sortRecursive(
(array) $this->decodeResponseJson()
));
foreach (Arr::sortRecursive($data) as $key => $value) {
$expected = substr(json_encode([$key => $value]), 1, -1);
PHPUnit::assertTrue(
Str::contains($actual, $expected),
'Unable to find JSON fragment: '.PHP_EOL.PHP_EOL.
"[{$expected}]".PHP_EOL.PHP_EOL.
'within'.PHP_EOL.PHP_EOL.
"[{$actual}]."
);
}
return $this;
}
/**
* Assert that the response does not contain the given JSON fragment.
*
* @param array $data
* @return $this
*/
public function assertJsonMissing(array $data)
{
$actual = json_encode(Arr::sortRecursive(
(array) $this->decodeResponseJson()
));
foreach (Arr::sortRecursive($data) as $key => $value) {
$expected = substr(json_encode([$key => $value]), 1, -1);
PHPUnit::assertFalse(
Str::contains($actual, $expected),
'Found unexpected JSON fragment: '.PHP_EOL.PHP_EOL.
"[{$expected}]".PHP_EOL.PHP_EOL.
'within'.PHP_EOL.PHP_EOL.
"[{$actual}]."
);
}
return $this;
}
/**
* Assert that the response has a given JSON structure.
*
* @param array|null $structure
* @param array|null $responseData
* @return $this
*/
public function assertJsonStructure(array $structure = null, $responseData = null)
{
if (is_null($structure)) {
return $this->assertJson($this->json());
}
if (is_null($responseData)) {
$responseData = $this->decodeResponseJson();
}
foreach ($structure as $key => $value) {
if (is_array($value) && $key === '*') {
PHPUnit::assertInternalType('array', $responseData);
foreach ($responseData as $responseDataItem) {
$this->assertJsonStructure($structure['*'], $responseDataItem);
}
} elseif (is_array($value)) {
PHPUnit::assertArrayHasKey($key, $responseData);
$this->assertJsonStructure($structure[$key], $responseData[$key]);
} else {
PHPUnit::assertArrayHasKey($value, $responseData);
}
}
return $this;
}
/**
* Validate and return the decoded response JSON.
*
* @return array
*/
public function decodeResponseJson()
{
$decodedResponse = json_decode($this->getContent(), true);
if (is_null($decodedResponse) || $decodedResponse === false) {
if ($this->exception) {
throw $this->exception;
} else {
PHPUnit::fail('Invalid JSON was returned from the route.');
}
}
return $decodedResponse;
}
/**
* Validate and return the decoded response JSON.
*
* @return array
*/
public function json()
{
return $this->decodeResponseJson();
}
/**
* Assert that the response view equals the given value.
*
* @param string $value
* @return $this
*/
public function assertViewIs($value)
{
$this->ensureResponseHasView();
PHPUnit::assertEquals($value, $this->original->getName());
return $this;
}
/**
* Assert that the response view has a given piece of bound data.
*
* @param string|array $key
* @param mixed $value
* @return $this
*/
public function assertViewHas($key, $value = null)
{
if (is_array($key)) {
return $this->assertViewHasAll($key);
}
$this->ensureResponseHasView();
if (is_null($value)) {
PHPUnit::assertArrayHasKey($key, $this->original->getData());
} elseif ($value instanceof Closure) {
PHPUnit::assertTrue($value($this->original->$key));
} else {
PHPUnit::assertEquals($value, $this->original->$key);
}
return $this;
}
/**
* Assert that the response view has a given list of bound data.
*
* @param array $bindings
* @return $this
*/
public function assertViewHasAll(array $bindings)
{
foreach ($bindings as $key => $value) {
if (is_int($key)) {
$this->assertViewHas($value);
} else {
$this->assertViewHas($key, $value);
}
}
return $this;
}
/**
* Assert that the response view is missing a piece of bound data.
*
* @param string $key
* @return $this
*/
public function assertViewMissing($key)
{
$this->ensureResponseHasView();
PHPUnit::assertArrayNotHasKey($key, $this->original->getData());
return $this;
}
/**
* Ensure that the response has a view as its original content.
*
* @return $this
*/
protected function ensureResponseHasView()
{
if (! isset($this->original) || ! $this->original instanceof View) {
return PHPUnit::fail('The response is not a view.');
}
return $this;
}
/**
* Assert that the session has a given value.
*
* @param string|array $key
* @param mixed $value
* @return $this
*/
public function assertSessionHas($key, $value = null)
{
if (is_array($key)) {
return $this->assertSessionHasAll($key);
}
if (is_null($value)) {
PHPUnit::assertTrue(
$this->session()->has($key),
"Session is missing expected key [{$key}]."
);
} else {
PHPUnit::assertEquals($value, app('session.store')->get($key));
}
return $this;
}
/**
* Assert that the session has a given list of values.
*
* @param array $bindings
* @return $this
*/
public function assertSessionHasAll(array $bindings)
{
foreach ($bindings as $key => $value) {
if (is_int($key)) {
$this->assertSessionHas($value);
} else {
$this->assertSessionHas($key, $value);
}
}
return $this;
}
/**
* Assert that the session has the given errors.
*
* @param string|array $keys
* @param mixed $format
* @return $this
*/
public function assertSessionHasErrors($keys = [], $format = null)
{
$this->assertSessionHas('errors');
$keys = (array) $keys;
$errors = app('session.store')->get('errors');
foreach ($keys as $key => $value) {
if (is_int($key)) {
PHPUnit::assertTrue($errors->has($value), "Session missing error: $value");
} else {
PHPUnit::assertContains($value, $errors->get($key, $format));
}
}
return $this;
}
/**
* Assert that the session does not have a given key.
*
* @param string|array $key
* @return $this
*/
public function assertSessionMissing($key)
{
if (is_array($key)) {
foreach ($key as $value) {
$this->assertSessionMissing($value);
}
} else {
PHPUnit::assertFalse(
$this->session()->has($key),
"Session has unexpected key [{$key}]."
);
}
return $this;
}
/**
* Get the current session store.
*
* @return \Illuminate\Session\Store
*/
protected function session()
{
return app('session.store');
}
/**
* Dump the content from the response.
*
* @return void
*/
public function dump()
{
$content = $this->getContent();
$json = json_decode($content);
if (json_last_error() === JSON_ERROR_NONE) {
$content = $json;
}
dd($content);
}
/**
* Dynamically access base response parameters.
*
* @param string $key
* @return mixed
*/
public function __get($key)
{
return $this->baseResponse->{$key};
}
/**
* Proxy isset() checks to the underlying base response.
*
* @param string $key
* @return mixed
*/
public function __isset($key)
{
return isset($this->baseResponse->{$key});
}
/**
* Handle dynamic calls into macros or pass missing methods to the base response.
*
* @param string $method
* @param array $args
* @return mixed
*/
public function __call($method, $args)
{
if (static::hasMacro($method)) {
return $this->macroCall($method, $args);
}
return $this->baseResponse->{$method}(...$args);
}
}
Mini Shell