AssertStructure::assertIsValidPrimarySingle() - Code Metrics - Inspection of "New minor version" - VGirol/JsonApi-Assert - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a787fa...dc9af5 )

by Vincent

created 2019-07-20 17:25 UTC

AssertStructure::assertIsValidPrimarySingle() A

↳ Parent: AssertStructure

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	4
c	0
b	0
f	0
dl	0
loc	9
rs	10
cc	2
nc	2
nop	2

<?php

declare(strict_types=1);

namespace VGirol\JsonApiAssert\Asserts\Structure;

use PHPUnit\Framework\Assert as PHPUnit;
use VGirol\JsonApiAssert\Members;
use VGirol\JsonApiAssert\Messages;

/**
 * Assertions relating to the overall structure of the document
 */
trait AssertStructure
{
    /**
     * Asserts that a json document has valid structure.
     *
     * @param array     $json
     * @param boolean   $strict     If true, unsafe characters are not allowed when checking members name.
     * @return void
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertHasValidStructure($json, bool $strict): void
    {
        static::assertHasValidTopLevelMembers($json);

        if (isset($json[Members::DATA])) {
            static::assertIsValidPrimaryData($json[Members::DATA], $strict);

            if (isset($json[Members::INCLUDED])) {
                static::assertIsValidIncludedCollection($json[Members::INCLUDED], $json[Members::DATA], $strict);
            }
        }

        if (isset($json[Members::ERRORS])) {
            static::assertIsValidErrorsObject($json[Members::ERRORS], $strict);
        }

        if (isset($json[Members::META])) {
            static::assertIsValidMetaObject($json[Members::META], $strict);
        }

        if (isset($json[Members::JSONAPI])) {
            static::assertIsValidJsonapiObject($json[Members::JSONAPI], $strict);
        }

        if (isset($json[Members::LINKS])) {
            static::assertIsValidTopLevelLinksMember($json[Members::LINKS], $strict);
        }
    }

    /**
     * Asserts that a json document has valid top-level structure.
     *
     * @param array $json
     * @return void
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertHasValidTopLevelMembers($json): void
    {
        $expected = [
            Members::DATA,
            Members::ERRORS,
            Members::META
        ];
        static::assertContainsAtLeastOneMember(
            $expected,
            $json,
            \sprintf(Messages::TOP_LEVEL_MEMBERS, implode('", "', $expected))
        );

        PHPUnit::assertFalse(
            isset($json[Members::DATA]) && isset($json[Members::ERRORS]),
            Messages::TOP_LEVEL_DATA_AND_ERROR
        );

        $allowed = [
            Members::DATA,
            Members::ERRORS,
            Members::META,
            Members::JSONAPI,
            Members::LINKS,
            Members::INCLUDED
        ];
        static::assertContainsOnlyAllowedMembers(
            $allowed,
            $json
        );

        PHPUnit::assertFALSE(
            !isset($json[Members::DATA]) && isset($json[Members::INCLUDED]),
            Messages::TOP_LEVEL_DATA_AND_INCLUDED
        );
    }

    /**
     * Asserts that a json fragment is a valid top-level links member.
     *
     * @param array     $json
     * @param boolean   $strict     If true, unsafe characters are not allowed when checking members name.
     * @return void
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertIsValidTopLevelLinksMember($json, bool $strict): void
    {
        $allowed = [
            Members::SELF,
            Members::RELATED,
            Members::FIRST,
            Members::LAST,
            Members::NEXT,
            Members::PREV
        ];
        static::assertIsValidLinksObject($json, $allowed, $strict);
    }

    /**
     * Asserts a json fragment is a valid primary data object.
     *
     * @param array|null    $json
     * @param boolean       $strict     If true, unsafe characters are not allowed when checking members name.
     * @return void
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertIsValidPrimaryData($json, bool $strict): void
    {
        if (\is_null($json)) {
            $json = [];
        }

        PHPUnit::assertIsArray(
            $json,
            Messages::PRIMARY_DATA_NOT_ARRAY
        );

        if (empty($json)) {
            return;
        }

        if (static::isArrayOfObjects($json)) {
            // Resource collection (Resource Objects or Resource Identifier Objects)
            static::assertIsValidPrimaryCollection($json, true, $strict);

            return;
        }

        // Single Resource (Resource Object or Resource Identifier Object)
        static::assertIsValidPrimarySingle($json, $strict);
    }

    /**
     * Asserts that a collection of resource object is valid.
     *
     * @param array     $list
     * @param boolean   $checkType      If true, asserts that all resources of the collection are of same type.
     * @param boolean   $strict         If true, excludes not safe characters when checking members name
     * @return void
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    private static function assertIsValidPrimaryCollection($list, bool $checkType, bool $strict): void
    {
        $isResourceObject = null;
        foreach ($list as $index => $resource) {
            if ($checkType) {
                // Assert that all resources of the collection are of same type.
                if ($index == 0) {
                    $isResourceObject = static::dataIsResourceObject($resource);
                    continue;
                }

                PHPUnit::assertEquals(
                    $isResourceObject,
                    static::dataIsResourceObject($resource),
                    Messages::PRIMARY_DATA_SAME_TYPE
                );
            }

            // Check the resource
            static::assertIsValidPrimarySingle($resource, $strict);
        }
    }

    /**
     * Assert that a single resource object is valid.
     *
     * @param array     $resource
     * @param boolean   $strict     If true, excludes not safe characters when checking members name
     * @return void
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    private static function assertIsValidPrimarySingle($resource, bool $strict): void
    {
        if (static::dataIsResourceObject($resource)) {
            static::assertIsValidResourceObject($resource, $strict);

            return;
        }

        static::assertIsValidResourceIdentifierObject($resource, $strict);
    }

    /**
     * Asserts that a collection of included resources is valid.
     *
     * @param array     $included   The included top-level member of the json document.
     * @param array     $data       The primary data of the json document.
     * @param boolean   $strict     If true, unsafe characters are not allowed when checking members name.
     * @return void
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertIsValidIncludedCollection($included, $data, bool $strict): void
    {
        static::assertIsValidResourceObjectCollection($included, $strict);

        $resIdentifiers = array_merge(
            static::getAllResourceIdentifierObjects($data),
            static::getAllResourceIdentifierObjects($included)
        );

        $present = [];
        foreach ($included as $inc) {
            PHPUnit::assertTrue(
                self::existsInArray($inc, $resIdentifiers),
                Messages::INCLUDED_RESOURCE_NOT_LINKED
            );

            if (!isset($present[$inc[Members::TYPE]])) {
                $present[$inc[Members::TYPE]] = [];
            }
            PHPUnit::assertNotContains(
                $inc[Members::ID],
                $present[$inc[Members::TYPE]],
                Messages::COMPOUND_DOCUMENT_ONLY_ONE_RESOURCE
            );
            array_push($present[$inc[Members::TYPE]], $inc[Members::ID]);
        }
    }

    /**
     * Checks if a given json fragment is a resource object.
     *
     * @param array $resource
     * @return bool
     */
    private static function dataIsResourceObject($resource): bool
    {
        $expected = [
            Members::ATTRIBUTES,
            Members::RELATIONSHIPS,
            Members::LINKS
        ];

        return static::containsAtLeastOneMember($expected, $resource);
    }

    /**
     * Get all the resource identifier objects (resource linkage) presents in a collection of resource.
     *
     * @param array $data
     * @return array
     */
    private static function getAllResourceIdentifierObjects($data): array
    {
        $arr = [];
        if (empty($data)) {
            return $arr;
        }
        if (!static::isArrayOfObjects($data)) {
            $data = [$data];
        }
        foreach ($data as $obj) {
            if (!isset($obj[Members::RELATIONSHIPS])) {
                continue;
            }
            foreach ($obj[Members::RELATIONSHIPS] as $relationship) {
                if (!isset($relationship[Members::DATA])) {
                    continue;
                }
                $arr = array_merge(
                    $arr,
                    static::isArrayOfObjects($relationship[Members::DATA]) ?
                        $relationship[Members::DATA] : [$relationship[Members::DATA]]
                );
            }
        }

        return $arr;
    }

    /**
     * Checks if a resource is present in a given array.
     *
     * @param array $needle
     * @param array $arr
     * @return bool
     */
    private static function existsInArray($needle, $arr): bool
    {
        foreach ($arr as $resIdentifier) {
            $test = $resIdentifier[Members::TYPE] === $needle[Members::TYPE]
                && $resIdentifier[Members::ID] === $needle[Members::ID];
            if ($test) {
                return true;
            }
        }

        return false;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace VGirol\JsonApiAssert\Asserts\Structure;
6
7			use PHPUnit\Framework\Assert as PHPUnit;
8			use VGirol\JsonApiAssert\Members;
9			use VGirol\JsonApiAssert\Messages;
10
11			/**
12			* Assertions relating to the overall structure of the document
13			*/
14			trait AssertStructure
15			{
16			/**
17			* Asserts that a json document has valid structure.
18			*
19			* @param array $json
20			* @param boolean $strict If true, unsafe characters are not allowed when checking members name.
21			* @return void
22			* @throws \PHPUnit\Framework\ExpectationFailedException
23			*/
24			public static function assertHasValidStructure($json, bool $strict): void
25			{
26			static::assertHasValidTopLevelMembers($json);
27
28			if (isset($json[Members::DATA])) {
29			static::assertIsValidPrimaryData($json[Members::DATA], $strict);
30
31			if (isset($json[Members::INCLUDED])) {
32			static::assertIsValidIncludedCollection($json[Members::INCLUDED], $json[Members::DATA], $strict);
33			}
34			}
35
36			if (isset($json[Members::ERRORS])) {
37			static::assertIsValidErrorsObject($json[Members::ERRORS], $strict);
38			}
39
40			if (isset($json[Members::META])) {
41			static::assertIsValidMetaObject($json[Members::META], $strict);
42			}
43
44			if (isset($json[Members::JSONAPI])) {
45			static::assertIsValidJsonapiObject($json[Members::JSONAPI], $strict);
46			}
47
48			if (isset($json[Members::LINKS])) {
49			static::assertIsValidTopLevelLinksMember($json[Members::LINKS], $strict);
50			}
51			}
52
53			/**
54			* Asserts that a json document has valid top-level structure.
55			*
56			* @param array $json
57			* @return void
58			* @throws \PHPUnit\Framework\ExpectationFailedException
59			*/
60			public static function assertHasValidTopLevelMembers($json): void
61			{
62			$expected = [
63			Members::DATA,
64			Members::ERRORS,
65			Members::META
66			];
67			static::assertContainsAtLeastOneMember(
68			$expected,
69			$json,
70			\sprintf(Messages::TOP_LEVEL_MEMBERS, implode('", "', $expected))
71			);
72
73			PHPUnit::assertFalse(
74			isset($json[Members::DATA]) && isset($json[Members::ERRORS]),
75			Messages::TOP_LEVEL_DATA_AND_ERROR
76			);
77
78			$allowed = [
79			Members::DATA,
80			Members::ERRORS,
81			Members::META,
82			Members::JSONAPI,
83			Members::LINKS,
84			Members::INCLUDED
85			];
86			static::assertContainsOnlyAllowedMembers(
87			$allowed,
88			$json
89			);
90
91			PHPUnit::assertFALSE(
92			!isset($json[Members::DATA]) && isset($json[Members::INCLUDED]),
93			Messages::TOP_LEVEL_DATA_AND_INCLUDED
94			);
95			}
96
97			/**
98			* Asserts that a json fragment is a valid top-level links member.
99			*
100			* @param array $json
101			* @param boolean $strict If true, unsafe characters are not allowed when checking members name.
102			* @return void
103			* @throws \PHPUnit\Framework\ExpectationFailedException
104			*/
105			public static function assertIsValidTopLevelLinksMember($json, bool $strict): void
106			{
107			$allowed = [
108			Members::SELF,
109			Members::RELATED,
110			Members::FIRST,
111			Members::LAST,
112			Members::NEXT,
113			Members::PREV
114			];
115			static::assertIsValidLinksObject($json, $allowed, $strict);
116			}
117
118			/**
119			* Asserts a json fragment is a valid primary data object.
120			*
121			* @param array\|null $json
122			* @param boolean $strict If true, unsafe characters are not allowed when checking members name.
123			* @return void
124			* @throws \PHPUnit\Framework\ExpectationFailedException
125			*/
126			public static function assertIsValidPrimaryData($json, bool $strict): void
127			{
128			if (\is_null($json)) {
129			$json = [];
130			}
131
132			PHPUnit::assertIsArray(
133			$json,
134			Messages::PRIMARY_DATA_NOT_ARRAY
135			);
136
137			if (empty($json)) {
138			return;
139			}
140
141			if (static::isArrayOfObjects($json)) {
142			// Resource collection (Resource Objects or Resource Identifier Objects)
143			static::assertIsValidPrimaryCollection($json, true, $strict);
144
145			return;
146			}
147
148			// Single Resource (Resource Object or Resource Identifier Object)
149			static::assertIsValidPrimarySingle($json, $strict);
150			}
151
152			/**
153			* Asserts that a collection of resource object is valid.
154			*
155			* @param array $list
156			* @param boolean $checkType If true, asserts that all resources of the collection are of same type.
157			* @param boolean $strict If true, excludes not safe characters when checking members name
158			* @return void
159			* @throws \PHPUnit\Framework\ExpectationFailedException
160			*/
161			private static function assertIsValidPrimaryCollection($list, bool $checkType, bool $strict): void
162			{
163			$isResourceObject = null;
164			foreach ($list as $index => $resource) {
165			if ($checkType) {
166			// Assert that all resources of the collection are of same type.
167			if ($index == 0) {
168			$isResourceObject = static::dataIsResourceObject($resource);
169			continue;
170			}
171
172			PHPUnit::assertEquals(
173			$isResourceObject,
174			static::dataIsResourceObject($resource),
175			Messages::PRIMARY_DATA_SAME_TYPE
176			);
177			}
178
179			// Check the resource
180			static::assertIsValidPrimarySingle($resource, $strict);
181			}
182			}
183
184			/**
185			* Assert that a single resource object is valid.
186			*
187			* @param array $resource
188			* @param boolean $strict If true, excludes not safe characters when checking members name
189			* @return void
190			* @throws \PHPUnit\Framework\ExpectationFailedException
191			*/
192			private static function assertIsValidPrimarySingle($resource, bool $strict): void
193			{
194			if (static::dataIsResourceObject($resource)) {
195			static::assertIsValidResourceObject($resource, $strict);
196
197			return;
198			}
199
200			static::assertIsValidResourceIdentifierObject($resource, $strict);
201			}
202
203			/**
204			* Asserts that a collection of included resources is valid.
205			*
206			* @param array $included The included top-level member of the json document.
207			* @param array $data The primary data of the json document.
208			* @param boolean $strict If true, unsafe characters are not allowed when checking members name.
209			* @return void
210			* @throws \PHPUnit\Framework\ExpectationFailedException
211			*/
212			public static function assertIsValidIncludedCollection($included, $data, bool $strict): void
213			{
214			static::assertIsValidResourceObjectCollection($included, $strict);
215
216			$resIdentifiers = array_merge(
217			static::getAllResourceIdentifierObjects($data),
218			static::getAllResourceIdentifierObjects($included)
219			);
220
221			$present = [];
222			foreach ($included as $inc) {
223			PHPUnit::assertTrue(
224			self::existsInArray($inc, $resIdentifiers),
225			Messages::INCLUDED_RESOURCE_NOT_LINKED
226			);
227
228			if (!isset($present[$inc[Members::TYPE]])) {
229			$present[$inc[Members::TYPE]] = [];
230			}
231			PHPUnit::assertNotContains(
232			$inc[Members::ID],
233			$present[$inc[Members::TYPE]],
234			Messages::COMPOUND_DOCUMENT_ONLY_ONE_RESOURCE
235			);
236			array_push($present[$inc[Members::TYPE]], $inc[Members::ID]);
237			}
238			}
239
240			/**
241			* Checks if a given json fragment is a resource object.
242			*
243			* @param array $resource
244			* @return bool
245			*/
246			private static function dataIsResourceObject($resource): bool
247			{
248			$expected = [
249			Members::ATTRIBUTES,
250			Members::RELATIONSHIPS,
251			Members::LINKS
252			];
253
254			return static::containsAtLeastOneMember($expected, $resource);
255			}
256
257			/**
258			* Get all the resource identifier objects (resource linkage) presents in a collection of resource.
259			*
260			* @param array $data
261			* @return array
262			*/
263			private static function getAllResourceIdentifierObjects($data): array
264			{
265			$arr = [];
266			if (empty($data)) {
267			return $arr;
268			}
269			if (!static::isArrayOfObjects($data)) {
270			$data = [$data];
271			}
272			foreach ($data as $obj) {
273			if (!isset($obj[Members::RELATIONSHIPS])) {
274			continue;
275			}
276			foreach ($obj[Members::RELATIONSHIPS] as $relationship) {
277			if (!isset($relationship[Members::DATA])) {
278			continue;
279			}
280			$arr = array_merge(
281			$arr,
282			static::isArrayOfObjects($relationship[Members::DATA]) ?
283			$relationship[Members::DATA] : [$relationship[Members::DATA]]
284			);
285			}
286			}
287
288			return $arr;
289			}
290
291			/**
292			* Checks if a resource is present in a given array.
293			*
294			* @param array $needle
295			* @param array $arr
296			* @return bool
297			*/
298			private static function existsInArray($needle, $arr): bool
299			{
300			foreach ($arr as $resIdentifier) {
301			$test = $resIdentifier[Members::TYPE] === $needle[Members::TYPE]
302			&& $resIdentifier[Members::ID] === $needle[Members::ID];
303			if ($test) {
304			return true;
305			}
306			}
307
308			return false;
309			}
310			}
311

VGirol / JsonApi-Assert

Push — master ( a787fa...dc9af5 )

AssertStructure::assertIsValidPrimarySingle() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like