%PDF-
%PDF-
Mini Shell
Mini Shell
<?php
namespace Illuminate\Testing;
use ArrayAccess;
use Closure;
use Countable;
use Illuminate\Contracts\Support\Jsonable;
use Illuminate\Support\Arr;
use Illuminate\Support\Str;
use Illuminate\Testing\Assert as PHPUnit;
use JsonSerializable;
class AssertableJsonString implements ArrayAccess, Countable
{
/**
* The original encoded json.
*
* @var \Illuminate\Contracts\Support\Jsonable|\JsonSerializable|array|string
*/
public $json;
/**
* The decoded json contents.
*
* @var array|null
*/
protected $decoded;
/**
* Create a new assertable JSON string instance.
*
* @param \Illuminate\Contracts\Support\Jsonable|\JsonSerializable|array|string $jsonable
* @return void
*/
public function __construct($jsonable)
{
$this->json = $jsonable;
if ($jsonable instanceof JsonSerializable) {
$this->decoded = $jsonable->jsonSerialize();
} elseif ($jsonable instanceof Jsonable) {
$this->decoded = json_decode($jsonable->toJson(), true);
} elseif (is_array($jsonable)) {
$this->decoded = $jsonable;
} else {
$this->decoded = json_decode($jsonable, true);
}
}
/**
* Validate and return the decoded response JSON.
*
* @param string|null $key
* @return mixed
*/
public function json($key = null)
{
return data_get($this->decoded, $key);
}
/**
* Assert that the response JSON has the expected count of items at the given key.
*
* @param int $count
* @param string|null $key
* @return $this
*/
public function assertCount(int $count, $key = null)
{
if (! is_null($key)) {
PHPUnit::assertCount(
$count, data_get($this->decoded, $key),
"Failed to assert that the response count matched the expected {$count}"
);
return $this;
}
PHPUnit::assertCount($count,
$this->decoded,
"Failed to assert that the response count matched the expected {$count}"
);
return $this;
}
/**
* Assert that the response has the exact given JSON.
*
* @param array $data
* @return $this
*/
public function assertExact(array $data)
{
$actual = $this->reorderAssocKeys((array) $this->decoded);
$expected = $this->reorderAssocKeys($data);
PHPUnit::assertEquals(
json_encode($expected, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES),
json_encode($actual, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES)
);
return $this;
}
/**
* Assert that the response has the similar JSON as given.
*
* @param array $data
* @return $this
*/
public function assertSimilar(array $data)
{
$actual = json_encode(
Arr::sortRecursive((array) $this->decoded),
JSON_UNESCAPED_UNICODE
);
PHPUnit::assertEquals(json_encode(Arr::sortRecursive($data), JSON_UNESCAPED_UNICODE), $actual);
return $this;
}
/**
* Assert that the response contains the given JSON fragment.
*
* @param array $data
* @return $this
*/
public function assertFragment(array $data)
{
$actual = json_encode(
Arr::sortRecursive((array) $this->decoded),
JSON_UNESCAPED_UNICODE
);
foreach (Arr::sortRecursive($data) as $key => $value) {
$expected = $this->jsonSearchStrings($key, $value);
PHPUnit::assertTrue(
Str::contains($actual, $expected),
'Unable to find JSON fragment: '.PHP_EOL.PHP_EOL.
'['.json_encode([$key => $value], JSON_UNESCAPED_UNICODE).']'.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
* @param bool $exact
* @return $this
*/
public function assertMissing(array $data, $exact = false)
{
if ($exact) {
return $this->assertMissingExact($data);
}
$actual = json_encode(
Arr::sortRecursive((array) $this->decoded),
JSON_UNESCAPED_UNICODE
);
foreach (Arr::sortRecursive($data) as $key => $value) {
$unexpected = $this->jsonSearchStrings($key, $value);
PHPUnit::assertFalse(
Str::contains($actual, $unexpected),
'Found unexpected JSON fragment: '.PHP_EOL.PHP_EOL.
'['.json_encode([$key => $value], JSON_UNESCAPED_UNICODE).']'.PHP_EOL.PHP_EOL.
'within'.PHP_EOL.PHP_EOL.
"[{$actual}]."
);
}
return $this;
}
/**
* Assert that the response does not contain the exact JSON fragment.
*
* @param array $data
* @return $this
*/
public function assertMissingExact(array $data)
{
$actual = json_encode(
Arr::sortRecursive((array) $this->decoded),
JSON_UNESCAPED_UNICODE
);
foreach (Arr::sortRecursive($data) as $key => $value) {
$unexpected = $this->jsonSearchStrings($key, $value);
if (! Str::contains($actual, $unexpected)) {
return $this;
}
}
PHPUnit::fail(
'Found unexpected JSON fragment: '.PHP_EOL.PHP_EOL.
'['.json_encode($data, JSON_UNESCAPED_UNICODE).']'.PHP_EOL.PHP_EOL.
'within'.PHP_EOL.PHP_EOL.
"[{$actual}]."
);
return $this;
}
/**
* Assert that the response does not contain the given path.
*
* @param string $path
* @return $this
*/
public function assertMissingPath($path)
{
PHPUnit::assertFalse(Arr::has($this->json(), $path));
return $this;
}
/**
* Assert that the expected value and type exists at the given path in the response.
*
* @param string $path
* @param mixed $expect
* @return $this
*/
public function assertPath($path, $expect)
{
if ($expect instanceof Closure) {
PHPUnit::assertTrue($expect($this->json($path)));
} else {
PHPUnit::assertSame($expect, $this->json($path));
}
return $this;
}
/**
* Assert that the response has a given JSON structure.
*
* @param array|null $structure
* @param array|null $responseData
* @return $this
*/
public function assertStructure(array $structure = null, $responseData = null)
{
if (is_null($structure)) {
return $this->assertSimilar($this->decoded);
}
if (! is_null($responseData)) {
return (new static($responseData))->assertStructure($structure);
}
foreach ($structure as $key => $value) {
if (is_array($value) && $key === '*') {
PHPUnit::assertIsArray($this->decoded);
foreach ($this->decoded as $responseDataItem) {
$this->assertStructure($structure['*'], $responseDataItem);
}
} elseif (is_array($value)) {
PHPUnit::assertArrayHasKey($key, $this->decoded);
$this->assertStructure($structure[$key], $this->decoded[$key]);
} else {
PHPUnit::assertArrayHasKey($value, $this->decoded);
}
}
return $this;
}
/**
* Assert that the response is a superset of the given JSON.
*
* @param array $data
* @param bool $strict
* @return $this
*/
public function assertSubset(array $data, $strict = false)
{
PHPUnit::assertArraySubset(
$data, $this->decoded, $strict, $this->assertJsonMessage($data)
);
return $this;
}
/**
* Reorder associative array keys to make it easy to compare arrays.
*
* @param array $data
* @return array
*/
protected function reorderAssocKeys(array $data)
{
$data = Arr::dot($data);
ksort($data);
$result = [];
foreach ($data as $key => $value) {
Arr::set($result, $key, $value);
}
return $result;
}
/**
* 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 | JSON_UNESCAPED_UNICODE);
$actual = json_encode($this->decoded, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
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;
}
/**
* Get the strings we need to search for when examining the JSON.
*
* @param string $key
* @param string $value
* @return array
*/
protected function jsonSearchStrings($key, $value)
{
$needle = Str::substr(json_encode([$key => $value], JSON_UNESCAPED_UNICODE), 1, -1);
return [
$needle.']',
$needle.'}',
$needle.',',
];
}
/**
* Get the total number of items in the underlying JSON array.
*
* @return int
*/
public function count(): int
{
return count($this->decoded);
}
/**
* Determine whether an offset exists.
*
* @param mixed $offset
* @return bool
*/
public function offsetExists($offset): bool
{
return isset($this->decoded[$offset]);
}
/**
* Get the value at the given offset.
*
* @param string $offset
* @return mixed
*/
public function offsetGet($offset): mixed
{
return $this->decoded[$offset];
}
/**
* Set the value at the given offset.
*
* @param string $offset
* @param mixed $value
* @return void
*/
public function offsetSet($offset, $value): void
{
$this->decoded[$offset] = $value;
}
/**
* Unset the value at the given offset.
*
* @param string $offset
* @return void
*/
public function offsetUnset($offset): void
{
unset($this->decoded[$offset]);
}
}
Zerion Mini Shell 1.0