ilUtilTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
use PHPUnit\Framework\TestCase;
use ILIAS\DI\Container;
use ILIAS\Refinery\Factory as Refinery;
use ILIAS\Refinery\String\Group as StringGroup;
use ILIAS\Refinery\Transformation;
use PHPUnit\Framework\MockObject\MockObject;
 
class ilUtilTest extends TestCase
{
    private const string HTTP_HOST = 'http://localhost';
 
    private ?Container $original_dic = null;
 
    protected function setUp(): void
    {
        global $DIC;
 
        $this->original_dic = is_object($DIC) ? clone $DIC : $DIC;
 
        parent::setUp();
    }
 
    protected function tearDown(): void
    {
        global $DIC;
 
        $DIC = $this->original_dic;
 
        parent::tearDown();
    }
 
    public function testMakeClickableWithoutGotoLinks(): void
    {
        global $DIC;
 
        $input = 'Small things make base men proud.';
        $expected = 'I do desire we may be better strangers.';
 
        $DIC = $this->mockClickableCall($input, $expected);
 
        $this->assertSame($expected, ilUtil::makeClickable($input));
    }
 
    #[\PHPUnit\Framework\Attributes\DataProvider('provideGotoLinkData')]
    public function testMakeClickableWithGotoLinksAndInvalidRefId(
        string $expected,
        string $input,
        array $ref_to_obj,
        array $obj_to_title
    ): void {
        global $DIC;
 
        $container = $this->mockClickableCall($input, $expected);
 
        $cache = $this->getMockBuilder(ilObjectDataCache::class)->disableOriginalConstructor()->getMock();
 
        $consecutive_id = [];
        foreach ($ref_to_obj as $k => $v) {
            $consecutive_id[] = [$k, $v];
        }
 
        $cache->expects($this->exactly(count($ref_to_obj)))
            ->method('lookupObjId')
            ->willReturnCallback(
                function ($id) use (&$consecutive_id) {
                    [$k, $v] = array_shift($consecutive_id);
                    $this->assertEquals($k, $id);
                    return $v;
                }
            );
 
        $consecutive_title = [];
        foreach ($obj_to_title as $k => $v) {
            $consecutive_title[] = [$k, $v];
        }
 
        $cache->expects($this->exactly(count($obj_to_title)))
            ->method('lookupTitle')
            ->willReturnCallback(
                function ($id) use (&$consecutive_title) {
                    [$k, $v] = array_shift($consecutive_title);
                    $this->assertEquals($k, $id);
                    return $v;
                }
            );
 
        $container->expects($this->exactly(count($ref_to_obj)))->method('offsetGet')->with('ilObjDataCache')->willReturn($cache);
 
        $DIC = $container;
 
        $this->assertSame($expected, ilUtil::makeClickable($input, true, self::HTTP_HOST));
    }
 
    public static function provideGotoLinkData(): array
    {
        // Please note that these test cases represent the current state, not necessarily the correct state.
        // For example all anchor attributes are REMOVED and the target is ALWAYS set to target="_self".
 
        $tests = [
            'Test with empty string.' => ['', '', [], []],
            'Test with correct link and target = _self is added.' => [
                'A link to <a href="%scrs_345%s" target="_self">a course</a>.',
                'A link to <a href="%scrs_345%s">somewhere</a>.',
                [345 => 5],
                [5 => 'a course'],
            ],
            'Test with multiple correct links.' => [
                'A link to <a href="%scrs_345%s" target="_self">a course</a> and to <a href="%scrs_87%s" target="_self">another course</a>.',
                'A link to <a href="%scrs_345%s">somewhere</a> and to <a href="%scrs_87%s">somewhere else</a>.',
                [345 => 5, 87 => 45],
                [5 => 'a course', 45 => 'another course'],
            ],
            'Test links with invalid ref id.' => [
                'A link to <a href="%scrs_345%s">somewhere</a>.',
                'A link to <a href="%scrs_345%s">somewhere</a>.',
                [345 => 0],
                [],
            ],
            'The target attribute is REPLACED with _self.' => [
                'A link to <a href="%scrs_345%s" target="_self">some course</a>.',
                'A link to <a target="bogus target" href="%scrs_345%s">somewhere</a>.',
                [345 => 8],
                [8 => 'some course'],
            ],
            'The attributes position does not matter, it is always replaced with target="_self".' => [
                'A link to <a href="%scrs_345%s" target="_self">some course</a>.',
                'A link to <a href="%scrs_345%s" target="bogus target">somewhere</a>.',
                [345 => 8],
                [8 => 'some course'],
            ],
            'All attributes are removed from the link.' => [
                'A link to <a href="%scrs_345%s" target="_self">some course</a>.',
                'A link to <a href="%scrs_345%s" class="very-important-css-class">somewhere</a>.',
                [345 => 8],
                [8 => 'some course'],
            ],
        ];
 
        $linkFormats = [
            'With goto.php: ' => [self::HTTP_HOST . '/goto.php?target=', ''],
            'With goto_*.html: ' => [self::HTTP_HOST . '/goto_', '.html'],
        ];
 
        $repeatForFormat = static function (string $format, array $values): array {
            return array_merge(
                ...array_fill(0, (count(explode('%s', $format)) - 1) / 2, $values)
            );
        };
 
        $allTests = [];
        foreach ($linkFormats as $name => $args) {
            foreach ($tests as $key => $array) {
                $allTests[$name . $key] = array_merge([
                    sprintf($array[0], ...$repeatForFormat($array[0], $args)),
                    sprintf($array[1], ...$repeatForFormat($array[1], $args)),
                ], array_slice($array, 2));
            }
        }
 
        return $allTests;
    }
 
    private function mockClickableCall(string $input, string $transformed): Container&MockObject
    {
        $transformation = $this->getMockBuilder(Transformation::class)->getMock();
        $transformation->expects($this->once())->method('transform')->with($input)->willReturn($transformed);
 
        $string_group = $this->getMockBuilder(StringGroup::class)->disableOriginalConstructor()->getMock();
        $string_group->expects($this->once())->method('makeClickable')->willReturn($transformation);
 
        $refinery = $this->getMockBuilder(Refinery::class)->disableOriginalConstructor()->getMock();
        $refinery->expects($this->once())->method('string')->willReturn($string_group);
 
        $container = $this->getMockBuilder(Container::class)->disableOriginalConstructor()->getMock();
        $container->expects($this->once())->method('refinery')->willReturn($refinery);
 
        return $container;
    }
}