TagInputTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
require_once(__DIR__ . "/../../../../../../../vendor/composer/vendor/autoload.php");
require_once(__DIR__ . "/../../../Base.php");
require_once(__DIR__ . "/InputTest.php");
require_once(__DIR__ . "/CommonFieldRendering.php");
 
use ILIAS\UI\Implementation\Component as I;
use ILIAS\Data;
use ILIAS\UI\URLBuilder;
use ILIAS\UI\URLBuilderToken;
 
class TagInputTest extends ILIAS_UI_TestBase
{
    use CommonFieldRendering;
 
    protected DefNamesource $name_source;
 
    public function setUp(): void
    {
        $this->name_source = new DefNamesource();
    }
 
    #[\PHPUnit\Framework\Attributes\DoesNotPerformAssertions]
    public function testImplementsFactoryInterface(): void
    {
        $f = $this->getFieldFactory();
 
        $f->tag(
            "label",
            ["lorem", "ipsum", "dolor"],
            "byline"
        );
    }
 
    public function testRender(): void
    {
        $f = $this->getFieldFactory();
        $label = "label";
        $byline = "byline";
        $tags = ["lorem", "ipsum", "dolor",];
        $tag = $f->tag($label, $tags, $byline)->withNameFrom($this->name_source);
        $expected = $this->getFormWrappedHtml(
            'tag-field-input',
            $label,
            '
            <div class="c-field-tag__wrapper">
                <input id="id_1" name="name_0" class="c-field-tag" value=""/>
            </div>
            ',
            $byline,
            'id_1',
            'id_2'
        );
        $this->assertEquals($expected, $this->renderInsideContainer($tag));
    }
 
    public function testCommonRendering(): void
    {
        $f = $this->getFieldFactory();
        $tag = $f->tag('label', [], null)->withNameFrom($this->name_source);
 
        $this->testWithError($tag);
        $this->testWithNoByline($tag);
        $this->testWithRequired($tag);
        $this->testWithDisabled($tag);
        $this->testWithAdditionalOnloadCodeRendersId($tag);
    }
 
    public function testValueRequired(): void
    {
        $f = $this->getFieldFactory();
        $label = "label";
        $name = "name_0";
        $tags = ["lorem", "ipsum", "dolor",];
        $tag = $f->tag($label, $tags)->withNameFrom($this->name_source)->withRequired(true);
 
        $raw_value1 = "lorem,ipsum";
        $expected_result = ['lorem', 'ipsum'];
        $tag1 = $tag->withInput(new DefInputData([$name => $raw_value1]));
        $value1 = $tag1->getContent();
        $this->assertTrue($value1->isOk());
        $value = $value1->value();
        $this->assertEquals($expected_result, $value);
    }
 
    public function testEmptyStringAsInputLeadToException(): void
    {
        $f = $this->getFieldFactory();
        $label = "label";
        $name = "name_0";
        $tags = ["lorem", "ipsum", "dolor",];
        $tag = $f->tag($label, $tags)->withNameFrom($this->name_source)->withRequired(true);
 
        $tag2 = $tag->withInput(new DefInputData([$name => '']));
        $result = $tag2->getContent();
        $this->assertFalse($result->isOk());
        try {
            $result->value();
            $this->fail();
        } catch (Exception $e) {
            $this->assertInstanceOf('ILIAS\Data\NotOKException', $e);
        }
    }
 
    public function testStringAsInputAsRequired(): void
    {
        $f = $this->getFieldFactory();
        $label = "label";
        $name = "name_0";
        $tags = ["lorem", "ipsum", "dolor",];
        $tag = $f->tag($label, $tags)->withNameFrom($this->name_source)->withRequired(true);
 
        $tag2 = $tag->withInput(new DefInputData([$name => 'test']));
        $result = $tag2->getContent();
        $this->assertTrue($result->isOk());
        $this->assertEquals(['test'], $result->value());
    }
 
    public function testNullValueLeadsToException(): void
    {
        $f = $this->getFieldFactory();
        $label = "label";
        $name = "name_0";
        $tags = ["lorem", "ipsum", "dolor",];
 
        $tag = $f->tag($label, $tags)->withNameFrom($this->name_source)->withRequired(true);
        $tag2 = $tag->withInput(new DefInputData([$name => null]));
        $value2 = $tag2->getContent();
        $this->assertTrue($value2->isError());
    }
 
    public function testUserCreatedNotAllowed(): void
    {
        $this->markTestSkipped("This is supposed to work, but currently does not.");
 
        $f = $this->getFieldFactory();
        $tags = ["lorem", "ipsum", "dolor",];
        $tag = $f->tag("label", $tags)->withUserCreatedTagsAllowed(false)->withNameFrom($this->name_source);
 
        $tag1 = $tag->withInput(
            new DefInputData(
                ["name_0" => "lorem,ipsum"]
            )
        );
        $value1 = $tag1->getContent();
        $this->assertTrue($value1->isOk());
        $value = $value1->value();
        $this->assertEquals(
            ["lorem", "ipsum"],
            $value
        );
 
        $tag1 = $tag->withInput(
            new DefInputData(
                ["name_0" => "conseptetuer,ipsum"]
            )
        );
        $value1 = $tag1->getContent();
        $this->assertTrue($value1->isError());
    }
 
    public function testMaxTagsOk(): void
    {
        $f = $this->getFieldFactory();
 
        $tag = $f->tag("label", [])->withMaxTags(3)->withNameFrom($this->name_source)->withInput(
            new DefInputData(["name_0" => "lorem,ipsum"])
        );
        $value = $tag->getContent();
        $this->assertTrue($value->isOk());
    }
 
    public function testMaxTagsNotOk(): void
    {
        $f = $this->getFieldFactory();
 
        $this->expectException(InvalidArgumentException::class);
        $f->tag("label", [])->withMaxTags(2)->withNameFrom($this->name_source)->withInput(
            new DefInputData(
                ["name_0" => "lorem,ipsum,dolor"]
            )
        );
    }
 
    public function testConfigurationDoesNotLimitAmountOfTagsByDefault(): void
    {
        $f = $this->getFieldFactory();
 
        $tag = $f->tag("label", []);
 
        $this->assertSame(I\Input\Field\Tag::INFINITE, $tag->getMaxTags());
        $this->assertSame(I\Input\Field\Tag::INFINITE, $tag->getConfiguration()->maxItems);
    }
 
    public function testConfigurationReflectsMaxTags(): void
    {
        $f = $this->getFieldFactory();
 
        $tag = $f->tag("label", [])->withMaxTags(42);
 
        $this->assertSame(42, $tag->getMaxTags());
        $this->assertSame(42, $tag->getConfiguration()->maxItems);
    }
 
    public function testMaxTaglengthTagsOk(): void
    {
        $f = $this->getFieldFactory();
 
        $tag = $f->tag("label", [])->withTagMaxLength(10)->withNameFrom($this->name_source)->withInput(
            new DefInputData(["name_0" => "lorem,ipsum"])
        );
        $value = $tag->getContent();
        $this->assertTrue($value->isOk());
    }
 
    public function testMaxTaglengthTagsNotOk(): void
    {
        $f = $this->getFieldFactory();
 
        $this->expectException(InvalidArgumentException::class);
        $f->tag("label", [])->withTagMaxLength(2)->withNameFrom($this->name_source)->withInput(
            new DefInputData(
                ["name_0" => "lorem,ipsum,dolor"]
            )
        );
    }
 
    public static function getUITagSpecialCharValues(): array
    {
        return [
            ['1', '2', '3'],
            ['++1#*', '[-2]', '{?3}'],
            ['some\'thing "else"', '&/\\'],
            ['fünf, sechs', 'sieben, acht'],
        ];
    }
 
    public function testUITagInputSpecialChars(string ...$tags): void
    {
        $f = $this->getFieldFactory();
        $name = "name_0";
        $tag = $f->tag('', $tags)->withNameFrom($this->name_source);
 
        $encoded_tags = array_map('rawurlencode', $tags);
 
        $this->assertEquals(
            $encoded_tags,
            array_map(
                fn($o) => $o['value'],
                $tag->getConfiguration(fn(string $txt) => $txt)->options
            )
        );
 
        $raw_value = implode(',', $encoded_tags);
        $tag_with_input = $tag->withInput(new DefInputData([$name => $raw_value]));
        $content = $tag_with_input->getContent();
        $this->assertTrue($content->isOk());
        $this->assertEquals($tags, $content->value());
    }
 
    public function testTagWithAutocompleteEndpoint(): void
    {
        $url_builder = new URLBuilder(new Data\URI('http://wwww.ilias.de?ref_id=1'));
        $token = new URLBuilderToken(['t'], 't');
        $f = $this->getFieldFactory();
        $tag = $f->tag('my_tag', []);
 
        $this->assertEquals(null, $tag->getAsyncAutocompleteEndpoint());
        $this->assertEquals(null, $tag->getAsyncAutocompleteToken());
 
        $tag = $tag->withAsyncAutocomplete(
            $url_builder,
            $token
        );
        $this->assertEquals($url_builder, $tag->getAsyncAutocompleteEndpoint());
        $this->assertEquals($token, $tag->getAsyncAutocompleteToken());
    }
 
    public function testTagWithAutocompleteEndpointJSAdded(): void
    {
        $token = $this->createMock(URLBuilderToken::class);
        $token->expects($this->once())
            ->method('render');
        $url_builder = $this->createMock(URLBuilder::class);
        $url_builder->expects($this->once())
            ->method('renderObject')
            ->with([$token]);
 
        $f = $this->getFieldFactory();
        $tag = $f->tag('my_tag', [])->withAsyncAutocomplete(
            $url_builder,
            $token
        );
 
        $renderer = $this->getDefaultRenderer();
        $renderer->render($tag);
    }
 
    public function testWithoutStripTags(): void
    {
        $tag = $this->getFieldFactory()->tag('my_tag', [])
            ->withoutStripTags()
            ->withNameFrom($this->name_source)
            ->withInput(new DefInputData(['name_0' => '<member>']));
 
        $result = $tag->getContent();
        $this->assertTrue($result->isOk());
        $this->assertSame(['<member>'], $result->value());
    }
}