VGirol\JsonApiAssert\Asserts\AssertBase

Complexity

Total Complexity

28

Size/Duplication

Total Lines	283
Duplicated Lines	0 %

Test Coverage

Coverage

97.4%

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	containsAtLeastOneMember()	0	5	1
A	assertHasData()	0	3	1
A	containsOnlyAllowedMembersConstraint()	0	3	1
A	assertHasMembers()	0	4	2
A	assertHasOnlyMembers()	0	6	1
A	assertHasIncluded()	0	3	1
A	assertHasRelationships()	0	3	1
A	assertContainsOnlyAllowedMembers()	0	4	1
A	assertNotHasMember()	0	3	1
A	assertHasErrors()	0	3	1
A	assertTestFail()	0	15	3
A	arrayIsAssociative()	0	3	1
A	assertIsArrayOfObjects()	0	5	2
A	assertHasMeta()	0	3	1
A	isArrayOfObjects()	0	10	3
A	assertHasMember()	0	3	1
A	assertHasAttributes()	0	3	1
A	containsAtLeastOneMemberConstraint()	0	3	1
A	assertContainsAtLeastOneMember()	0	3	1
A	assertHasLinks()	0	3	1
A	assertIsNotArrayOfObjects()	0	5	2

<?php
namespace VGirol\JsonApiAssert\Asserts;

use PHPUnit\Framework\Assert as PHPUnit;
use VGirol\JsonApiAssert\Messages;
use PHPUnit\Framework\ExpectationFailedException;
use VGirol\JsonApiAssert\Constraint\ContainsAtLeastOneConstraint;
use VGirol\JsonApiAssert\Constraint\ContainsOnlyAllowedMembersConstraint;

trait AssertBase
{
    /**
     * Asserts that a json object has expected members.
     *
     * @param array     $expected
     * @param array     $json
     *
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertHasMembers(array $expected, $json)
    {
        foreach ($expected as $key) {
            PHPUnit::assertArrayHasKey($key, $json, sprintf(Messages::HAS_MEMBER, $key));
        }
    }

    /**
     * Asserts that a json object has an expected member.
     *
     * @param string    $expected
     * @param array     $json
     *
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertHasMember($expected, $json)
    {
        PHPUnit::assertArrayHasKey($expected, $json, sprintf(Messages::HAS_MEMBER, $expected));
    }

    /**
     * Asserts that a json object has only expected members.
     *
     * @param array     $expected
     * @param array     $json
     *
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertHasOnlyMembers(array $expected, $json)
    {
        PHPUnit::assertEquals(
            $expected,
            array_keys($json),
            sprintf(Messages::HAS_ONLY_MEMBERS, implode(', ', $expected))
        );
    }

    /**
     * Asserts that a json object not has an unexpected member.
     *
     * @param string    $expected
     * @param array     $json
     *
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertNotHasMember($expected, $json)
    {
        PHPUnit::assertArrayNotHasKey($expected, $json, sprintf(Messages::NOT_HAS_MEMBER, $expected));
    }

    /**
     * Asserts that a json object has a "data" member.
     *
     * @param array     $json
     *
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertHasData($json)
    {
        static::assertHasMember('data', $json);
    }

    /**
     * Asserts that a json object has an "attributes" member.
     *
     * @param array     $json
     *
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertHasAttributes($json)
    {
        static::assertHasMember('attributes', $json);
    }

    /**
     * Asserts that a json object has a "links" member.
     *
     * @param array     $json
     *
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertHasLinks($json)
    {
        static::assertHasMember('links', $json);
    }

    /**
     * Asserts that a json object has a "meta" member.
     *
     * @param array     $json
     *
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertHasMeta($json)
    {
        static::assertHasMember('meta', $json);
    }

    /**
     * Asserts that a json object has an "included" member.
     *
     * @param array     $json
     *
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertHasIncluded($json)
    {
        static::assertHasMember('included', $json);
    }

    /**
     * Asserts that a json object has a "relationships" member.
     *
     * @param array     $json
     *
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertHasRelationships($json)
    {
        static::assertHasMember('relationships', $json);
    }

    /**
     * Asserts that a json object has an "errors" member.
     *
     * @param array     $json
     *
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertHasErrors($json)
    {
        static::assertHasMember('errors', $json);
    }

    /**
     * Asserts that a json object contains at least one member from the list provided.
     *
     * @param array $expected   The expected members
     * @param array $json       The json object
     * @param string $message   An optional message to explain why the test failed
     *
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertContainsAtLeastOneMember($expected, $json, $message = '')
    {
        PHPUnit::assertThat($json, self::containsAtLeastOneMemberConstraint($expected), $message);
    }

    /**
     * Returns a new instance of the \VGirol\JsonApiAssert\Constraint\ContainsAtLeastOneConstraint class.
     *
     * @param array $expected   The expected members
     *
     * @return \VGirol\JsonApiAssert\Constraint\ContainsAtLeastOneConstraint
     */
    public static function containsAtLeastOneMemberConstraint($expected)
    {
        return new ContainsAtLeastOneConstraint($expected);
    }

    /**
     * Check if a json object contains at least one member from the list provided.
     *
     * @param array $expected   The expected members
     * @param array $json       The json object
     *
     * @return boolean
     */
    public static function containsAtLeastOneMember($expected, $json)
    {
        $constraint = static::containsAtLeastOneMemberConstraint($expected);

        return $constraint->check($json);
    }

    /**
     * Asserts that a json object contains only members from the list provided.
     *
     * @param array $expected   The expected members
     * @param array $json       The json object
     * @param string $message   An optional message to explain why the test failed
     *
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertContainsOnlyAllowedMembers($expected, $json, $message = '')
    {
        $message = Messages::ONLY_ALLOWED_MEMBERS . "\n" . $message;
        PHPUnit::assertThat($json, self::containsOnlyAllowedMembersConstraint($expected), $message);
    }

    /**
     * Returns a new instance of the \VGirol\JsonApiAssert\Constraint\ContainsOnlyAllowedMembersConstraint class.
     *
     * @param array $expected   The expected members
     *
     * @return \VGirol\JsonApiAssert\Constraint\ContainsOnlyAllowedMembersConstraint
     */
    public static function containsOnlyAllowedMembersConstraint($expected)
    {
        return new ContainsOnlyAllowedMembersConstraint($expected);
    }

    /**
     * Asserts that an array is an array of objects.
     *
     * @param array     $data
     * @param string    $message   An optional message to explain why the test failed
     *
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertIsArrayOfObjects($data, $message = '')
    {
        $message = $message ?: Messages::MUST_BE_ARRAY_OF_OBJECTS;
        PHPUnit::assertIsArray($data, $message);
        PHPUnit::assertTrue(static::isArrayOfObjects($data), $message);
    }

    /**
     * Asserts that an array is not an array of objects.
     *
     * @param array     $data
     * @param string    $message   An optional message to explain why the test failed
     *
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertIsNotArrayOfObjects($data, $message = '')
    {
        $message = $message ?: Messages::MUST_NOT_BE_ARRAY_OF_OBJECTS;
        PHPUnit::assertIsArray($data, $message);
        PHPUnit::assertFalse(static::isArrayOfObjects($data), $message);
    }

    /**
     * Asserts that a test failed.
     *
     * @param \Closure|callback $fn
     * @param string $expectedFailureMessage
     * @param mixed $args
     *
     * @throws \PHPUnit\Framework\ExpectationFailedException
     */
    public static function assertTestFail($fn, $expectedFailureMessage)
    {
        $args = array_slice(func_get_args(), 2);

        try {
            call_user_func_array($fn, $args);
        } catch (ExpectationFailedException $e) {
            if (!is_null($expectedFailureMessage)) {
                PHPUnit::assertStringContainsString($expectedFailureMessage, $e->getMessage());
            }

            return;
        }

        throw new ExpectationFailedException(Messages::TEST_FAILED);
    }

    private static function isArrayOfObjects($arr)
    {
        if (!is_array($arr)) {
            return false;
        }
        if (empty($arr)) {
            return true;
        }

        return !static::arrayIsAssociative($arr);
    }

    private static function arrayIsAssociative($arr)
    {
        return (array_keys($arr) !== range(0, count($arr) - 1));
    }
}