Subreality\Dilmun\Anshar\Http\UriParts\UriPartTestCase

Complexity

Total Complexity

9

Size/Duplication

Total Lines	105
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	assertSameAsToString()	0	5	1
A	assertNotSameAsToString()	0	5	1
A	assertIsValid()	0	7	1
A	assertIsNotValid()	0	7	1
A	expectInvalidArgumentExceptionWhenConstructedWithInvalidData()	0	21	3
A	compareExceptionMessage()	0	10	2

<?php
namespace Subreality\Dilmun\Anshar\Http\UriParts;

/**
 * Class Assertions
 * @package Subreality\Dilmun\Anshar\PhpUnit
 */
class UriPartTestCase extends \PHPUnit_Framework_TestCase
{
    /**
     * Asserts that the given expected string is the same as the string returned by an object instance's __toString
     * magic method.
     *
     * @param string $expected                    The string expected to match
     * @param UriPartInterface $test_instance     An instance of the object whose __toString method is under test
     */
    public static function assertSameAsToString($expected, UriPartInterface $test_instance)
    {
        $actual = (string) $test_instance;
        self::assertSame($expected, $actual);
    }

    /**
     * Asserts that the given expected string is not the same as the string returned by an object instance's __toString
     * magic method.
     *
     * @param string $expected                  The string expected not to match
     * @param UriPartInterface $test_instance   An instance of the object whose __toString method is under test
     */
    public static function assertNotSameAsToString($expected, UriPartInterface $test_instance)
    {
        $actual = (string) $test_instance;
        self::assertNotSame($expected, $actual);
    }

    /**
     * Asserts that the given data is valid for the given class.
     *
     * @param mixed $data   The data expected to be valid
     * @param string $class The class whose isValid method is under test
     */
    public static function assertIsValid($data, $class)
    {
        /** @noinspection PhpUndefinedMethodInspection */
        $is_valid = $class::isValid($data);

        self::assertTrue($is_valid);
    }

    /**
     * Asserts that the given data is not valid for the given class.
     *
     * @param mixed $data   The data expected to be not valid
     * @param string $class The class whose isValid method is under test
     */
    public static function assertIsNotValid($data, $class)
    {
        /** @noinspection PhpUndefinedMethodInspection */
        $is_valid = $class::isValid($data);

        self::assertFalse($is_valid);
    }

    /**
     * Tests whether the constructor of a given class throws an \InvalidArgumentException when attempting to construct
     * an instance with invalid data.
     *
     * @param string $class_name    The name of the class to test
     * @param mixed $data           Data to be passed to the class's constructor
     * @param string|null $message  [optional] The expected \InvalidArgumentException message
     */
    public static function expectInvalidArgumentExceptionWhenConstructedWithInvalidData(
        $class_name,
        $data,
        $message = null
    ) {
        $exception_thrown = false;

        try {
            $non_string_instance = new $class_name($data);
        } catch (\InvalidArgumentException $exception) {
            self::compareExceptionMessage($exception, $message);

            $exception_thrown = true;
        } finally {
            unset($non_string_instance);
        }

        if (!$exception_thrown) {
            throw new \PHPUnit_Framework_ExpectationFailedException("Expected InvalidArgumentException not thrown");
        }
    }

    /**
     * Compares a given exceptions message with a given message string.
     *
     * @throws \PHPUnit_Framework_AssertionFailedError when exception message does not match given message
     *
     * @param \Exception $exception     An exception for message comparison
     * @param string $message           The intended message
     */
    private static function compareExceptionMessage(\Exception $exception, $message)
    {
        if (isset($message)) {
            self::assertSame(
                $message,
                $exception->getMessage(),
                "Failed asserting that {$exception->getMessage()} is the same as {$message}"
            );
        }
    }
}