SignpostMarv\DaftObject\Tests\DaftTestObjectTest::testGood()

Complexity

Conditions	23
Paths	270

Size

Total Lines	181
Code Lines	112

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function testGood(
        string $implementation,
        array $params,
        bool $readable = false,
        bool $writeable = false
    ) : void {
        /**
        * @var DaftObject $obj
        */
        $obj = new $implementation($params, $writeable);

        if (true === $readable) {
            $this->assertSame(
                ($writeable ? count($params) : 0),
                count($obj->ChangedProperties())
            );

            foreach ($params as $k => $v) {
                $getterMethod = 'Get' . ucfirst($k);

                $this->assertSame(
                    $params[$k],
                    $obj->$getterMethod(),
                    (
                        $implementation .
                        '::' .
                        $getterMethod .
                        '() does not match supplied $params'
                    )
                );
                $this->assertSame(
                    $params[$k],
                    $obj->$k,
                    (
                        $implementation .
                        '::$' .
                        $k .
                        ' does not match supplied $params'
                    )
                );

                $this->assertSame(
                    (is_null($params[$k]) ? false : true),
                    isset($obj->$k),
                    (
                        $implementation .
                        '::$' .
                        $k .
                        ' was not found as ' .
                        (is_null($params[$k]) ? 'not set' : 'set')
                    )
                );
            }
        }

        foreach (array_keys($params) as $property) {
            $this->assertSame(
                $writeable,
                $obj->HasPropertyChanged($property),
                (
                    $implementation .
                    '::$' .
                    $property .
                    ' was' .
                    ($writeable ? ' ' : ' not ') .
                    'writeable, property should' .
                    ($writeable ? ' ' : ' not ') .
                    'be changed'
                )
            );

            if ($writeable) {
                $obj->MakePropertiesUnchanged($property);
                $this->assertFalse($obj->HasPropertyChanged($property));

                if (
                    in_array(
                        $property,
                        $implementation::DaftObjectNullableProperties(),
                        true
                    )
                ) {
                    if ($obj instanceof DaftObjectWorm) {
                        $this->expectException(
                            PropertyNotRewriteableException::class
                        );
                        $this->expectExceptionMessage(
                            sprintf(
                                'Property not rewriteable: %s::$%s',
                                $implementation,
                                $property
                            )
                        );
                    }
                    unset($obj->$property);
                    $obj->$property = null;
                }
            }
        }

        $obj->MakePropertiesUnchanged(...array_keys($params));

        ob_start();
        var_dump($obj);

var_dump($obj) looks like debug code. Are you sure you do not want to remove it?

        $debugInfo = ob_get_clean();

        $props = [];

        foreach ($obj::DaftObjectExportableProperties() as $prop) {
            $expectedMethod = 'Get' . ucfirst($prop);
            if (
                $obj->__isset($prop) &&
                method_exists($obj, $expectedMethod) &&
                (
                    new ReflectionMethod($obj, $expectedMethod)
                )->isPublic()
            ) {
                $props[$prop] = $obj->$expectedMethod();
            }
        }

        $regex =
            '/(?:class |object\()' .
            preg_quote(get_class($obj), '/') .
            '[\)]{0,1}#' .
            '\d+ \(' .
            preg_quote((string) count($props), '/') .
            '\) \{.+';

        foreach ($props as $prop => $val) {
            $regex .=
                ' (?:public ' .
                preg_quote('$' . $prop, '/') .
                '|' .
                preg_quote('["' . $prop . '"]', '/') .
                ')[ ]{0,1}' .
                preg_quote('=', '/') .
                '>.+' .
                (
                    is_int($val)
                        ? 'int'
                        : (
                            is_bool($val)
                                ? 'bool'
                                : (
                                    is_float($val)
                                        ? '(?:float|double)'
                                        : preg_quote(gettype($val), '/')
                                )
                        )
                ) .
                preg_quote(
                    (
                        '(' .
                        (
                            is_string($val)
                                ? mb_strlen($val, '8bit')
                                : (
                                    is_numeric($val)
                                        ? (string) $val
                                        : var_export($val, true)
                                )
                        ) .
                        ')' .
                        (
                            is_string($val)
                                ? (' "' . $val . '"')
                                : ''
                        )
                    ),
                    '/'
                ) .
                '.+';
        }

        $regex .= '\}.+$/s';

        $this->assertRegExp(
            $regex,
            str_replace("\n", ' ', (string) $debugInfo)
        );