ilTestBaseTestCase.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

require_once __DIR__ . '/ilTestBaseTestCaseTrait.php';

use PHPUnit\Framework\TestCase;
use ILIAS\DI\Container;

class ilTestBaseTestCase extends TestCase
{
    use ilTestBaseTestCaseTrait;

    public const string MOCKED_METHOD_WITHOUT_OUTPUT = 'MOCKED_METHOD_WITHOUT_OUTPUT';
    public const string DYNAMIC_CLASS = 'DynamicClass';
    protected static int $DYNAMIC_CLASS_COUNT = 0;
    protected ?Container $dic = null;
    protected ?Container $backup_dic = null;

    protected function setUp(): void
    {
        error_reporting(E_ALL);
        $this->defineGlobalConstants();

        global $DIC;
        $this->backup_dic = is_object($DIC) ? clone $DIC : $DIC;

        $DIC = $this->getMockBuilder(Container::class)->onlyMethods([])->getMock();
        $this->addGlobals();
        $this->dic = $DIC;

        parent::setUp();
    }

    protected function tearDown(): void
    {
        global $DIC;

        $DIC = $this->backup_dic;

        parent::tearDown();
    }

    private function addGlobals(): void
    {
        $this->addGlobal_ilAccess();
        $this->addGlobal_dataFactory();
        $this->addGlobal_tpl();
        $this->addGlobal_ilDB();
        $this->addGlobal_ilUser();
        $this->addGlobal_ilias();
        $this->addGlobal_ilErr();
        $this->addGlobal_tree();
        $this->addGlobal_lng();
        $this->addGlobal_resourceStorage();
        $this->addGlobal_ilAppEventHandler();
        $this->addGlobal_objDefinition();
        $this->addGlobal_refinery();
        $this->addGlobal_rbacsystem();
        $this->addGlobal_rbacreview();
        $this->addGlobal_ilRbacAdmin();
        $this->addGlobal_http();
        $this->addGlobal_fileDelivery();
        $this->addGlobal_ilComponentFactory();
        $this->addGlobal_ilComponentRepository();
        $this->addGlobal_uiFactory();
        $this->addGlobal_uiRenderer();
        $this->addGlobal_uiService();
        $this->addGlobal_static_url();
        $this->addGlobal_upload();
        $this->addGlobal_ilLog();
        $this->addGlobal_ilBench();
        $this->addGlobal_ilSetting();
        $this->addGlobal_ilCtrl();
        $this->addGlobal_ilCtrl();
        $this->addGlobal_ilObjDataCache();
        $this->addGlobal_ilHelp();
        $this->addGlobal_ilTabs();
        $this->addGlobal_ilLocator();
        $this->addGlobal_ilToolbar();
        $this->addGlobal_filesystem();
        $this->addGlobal_ilLoggerFactory();
        $this->addGlobal_GlobalScreenService();
        $this->addGlobal_ilNavigationHistory();
        $this->addGlobal_objectService();
        $this->addGlobal_resourceStorage();
        $this->addGlobal_objectMetadata();

        $this->defineGlobalConstants();

        $this->prepareLocalDIC();

        parent::setUp();
    }

    private function prepareLocalDIC(): void
    {
        (new ReflectionClass(\ILIAS\Test\TestDIC::class))
            ->getProperty('dic')->setValue(null, null);
    }

    public static function callMethod($obj, $name, array $args = [])
    {
        return (new ReflectionClass($obj))->getMethod($name)->invokeArgs($obj, $args);
    }

    public static function getNonPublicPropertyValue(object $obj, string $name): mixed
    {
        $reflection_class = new ReflectionClass($obj);

        while ($reflection_class !== false && !$reflection_class->hasProperty($name)) {
            $reflection_class = $reflection_class->getParentClass();
        }

        return $reflection_class
            ? $reflection_class->getProperty($name)->getValue($obj)
            : throw new ReflectionException('Property not found.');
    }

    public function createInstanceOf(string $class_name, array $explicit_parameters = []): object
    {
        $constructor = (new ReflectionClass($class_name))->getConstructor();

        if ($constructor === null) {
            return new $class_name();
        }

        $parameters = [];

        foreach ($constructor->getParameters() as $constructor_parameter) {
            $constructor_parameter_name = $constructor_parameter->getName();

            if (isset($explicit_parameters[$constructor_parameter_name])) {
                $parameters[$constructor_parameter_name] = $explicit_parameters[$constructor_parameter_name];
                continue;
            }

            if ($constructor_parameter->isDefaultValueAvailable()) {
                $parameters[$constructor_parameter_name] = $constructor_parameter->getDefaultValue();
                continue;
            }

            if (!$constructor_parameter->hasType()) {
                throw new Exception('Constructor parameter has no type.');
            }

            $constructor_parameter_type_name = $constructor_parameter->getType()?->getName();
            $parameters[$constructor_parameter_name] = match ($constructor_parameter_type_name) {
                'string' => '',
                'int' => 0,
                'float' => 0.0,
                'bool', 'true' => true,
                'false' => false,
                'array' => [],
                'null', 'resource' => null,
                'Closure' => (static fn() => null),
                'object' => (object) [],
                default => (function ($constructor_parameter_type_name) {
                    if (enum_exists($constructor_parameter_type_name)) {
                        $enum_cases = $constructor_parameter_type_name::cases();
                        return array_shift($enum_cases);
                    }

                    return $this->getOrCreateMock($constructor_parameter_type_name);
                })($constructor_parameter_type_name)
            };
        }

        return new $class_name(...$parameters);
    }

    public function createTraitInstanceOf(string $class_name, array $explicit_parameters = []): object
    {
        if (trait_exists($class_name)) {
            $dynamic_class_name = self::DYNAMIC_CLASS . ++self::$DYNAMIC_CLASS_COUNT;
            eval("class $dynamic_class_name{use $class_name;}");
            return $this->createInstanceOf($dynamic_class_name, $explicit_parameters);
        }

        return $this->createInstanceOf($class_name, $explicit_parameters);
    }

    private function getOrCreateMock(string $parameter_type): PHPUnit\Framework\MockObject\MockObject
    {
        if (isset($this->services[$parameter_type])) {
            global $DIC;
            if (!isset($DIC[$this->services[$parameter_type]])) {
                $DIC[$this->services[$parameter_type]] = $this->createMock($parameter_type);
            }

            return $DIC[$this->services[$parameter_type]];
        }

        return $this->createMock($parameter_type);
    }
}