LanguageActivityTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\Language\Tests\Activities;
 
use ILIAS\AccessControl\PublicInterface\RBAC;
use ILIAS\Data\Description;
use ILIAS\Data\Text;
use ILIAS\Language\Activities\LanguageActivity;
use ILIAS\Language\ComponentTranslation\TranslationMarkupPolicy;
use ILIAS\Language\LanguageFolder;
use ILIAS\UI\Component\Input\Container\Form\FormInput;
use ILIAS\UI\Component\Input\Field\Factory as FieldFactory;
use ilLanguageBaseTestCase;
use PHPUnit\Framework\Attributes\DataProvider;
 
class LanguageActivityTest extends ilLanguageBaseTestCase
{
    use RealFieldsUiFactory;
 
    public function testExceptionWhileBuildingTheInputDescriptionIsMaskedAsA500ResultError(): void
    {
        $rbac = $this->createMock(\ilRbacSystem::class);
        $rbac->expects($this->never())->method('checkAccessOfUser');
 
        $activity = new LanguageActivityThrowingInputDescriptionTestDouble(
            $this->rbacOf($rbac),
            $this->languageFolder()
        );
 
        $result = $activity->maybePerformAs($this->createRealFieldsUiFactory()->input(), 6, []);
 
        $this->assertTrue($result->isError());
        $error = $result->error();
        $this->assertInstanceOf(\RuntimeException::class, $error);
        $this->assertSame(500, $error->getCode());
        $this->assertSame('The activity could not be performed.', $error->getMessage());
        $this->assertInstanceOf(\RuntimeException::class, $error->getPrevious());
        $this->assertSame('simulated failure while building the input description', $error->getPrevious()->getMessage());
    }
 
    public function testATypeErrorWhileBuildingTheInputDescriptionIsMaskedAsA500ResultError(): void
    {
        $activity = new LanguageActivityThrowingInputDescriptionTestDouble(
            $this->rbacOf($this->createMock(\ilRbacSystem::class)),
            $this->languageFolder(),
            throw_type_error: true,
        );
 
        $error = $activity->maybePerformAs($this->createRealFieldsUiFactory()->input(), 6, [])->error();
 
        $this->assertInstanceOf(\RuntimeException::class, $error);
        $this->assertSame(500, $error->getCode());
        $this->assertStringNotContainsString('TypeError', $error->getMessage());
        $this->assertInstanceOf(\TypeError::class, $error->getPrevious());
    }
 
    public function testADefectThrownByGrindIsMaskedAsA500ResultError(): void
    {
        $activity = new LanguageActivityPerformEchoTestDouble(
            $this->rbacOf($this->createMock(\ilRbacSystem::class)),
            $this->languageFolder(),
            $this->createMock(FormInput::class),
        );
 
        $error = $activity->maybePerformAs($this->createRealFieldsUiFactory()->input(), 6, [])->error();
 
        $this->assertSame(500, $error->getCode());
        $this->assertInstanceOf(\LogicException::class, $error->getPrevious());
    }
 
    public static function unknownUserIdProvider(): array
    {
        return ['zero' => [0], 'negative' => [-1], 'anonymous' => [null]];
    }
 
    #[DataProvider('unknownUserIdProvider')]
    public function testIsAllowedToPerformRefusesNonUsersWithoutAskingRbac(?int $usr_id): void
    {
        if (!defined('ANONYMOUS_USER_ID')) {
            define('ANONYMOUS_USER_ID', 13);
        }
        $usr_id ??= ANONYMOUS_USER_ID;
 
        $rbac_system = $this->createMock(\ilRbacSystem::class);
        $rbac_system->expects($this->never())->method('checkAccessOfUser');
 
        $activity = new LanguageActivityPerformEchoTestDouble(
            $this->rbacOf($rbac_system),
            $this->languageFolder()
        );
 
        $this->assertFalse($activity->isAllowedToPerform($usr_id, []));
    }
 
    public function testMaybePerformAsAnswers403ForANonUserAndNeverPerforms(): void
    {
        $rbac_system = $this->createMock(\ilRbacSystem::class);
        $rbac_system->expects($this->never())->method('checkAccessOfUser');
 
        $activity = new LanguageActivityPerformEchoTestDouble(
            $this->rbacOf($rbac_system),
            $this->languageFolder()
        );
 
        $error = $activity->maybePerformAs($this->createRealFieldsUiFactory()->input(), 0, [])->error();
 
        $this->assertSame(403, $error->getCode());
    }
 
    public function testMaybePerformAsPassesTheTrustedUsrIdToPerformOverASpoofedFormKey(): void
    {
        $rbac = $this->createStub(\ilRbacSystem::class);
        $rbac->method('checkAccessOfUser')->willReturn(true);
 
        $activity = new LanguageActivityPerformEchoTestDouble(
            $this->rbacOf($rbac),
            $this->languageFolder()
        );
 
        $result = $activity->maybePerformAs($this->createRealFieldsUiFactory()->input(), 42, []);
 
        $this->assertFalse($result->isError());
        $parameters = $result->value();
        // the trusted usr_id (42) wins over the spoofed one from normalizeParameters()
        $this->assertSame(42, $parameters['usr_id']);
        // a non-colliding key survives the merge
        $this->assertSame('form', $parameters['source']);
    }
 
    public function testInvalidMarkupCustomizingEntriesAppendTheMarkupConcernedToEachEntry(): void
    {
        $policy = new TranslationMarkupPolicy();
        $skipped = [
            'de' => [
                'tos#:#x' => $policy->findViolations('<script>a</script><script>b</script></form>'),
                'tos#:#plain' => [],
            ],
            'en' => ['tos#:#y' => $policy->findViolations('<script>a</script>')],
            'fr' => ['tos#:#z' => $policy->findViolations('<script>a</script>')],
        ];
        $activity = new LanguageActivityInvalidMarkupTestDouble(
            $this->rbacOf($this->createStub(\ilRbacSystem::class)),
            $this->languageFolder()
        );
 
        $this->assertSame(
            ['en: tos#:#y: <script>', 'de: tos#:#x: <script>, </form>', 'de: tos#:#plain'],
            $activity->entries($skipped, ['en', 'de', 'it'])
        );
    }
 
    public function testDuplicateCustomizingEntriesNameWhatEachEntryWouldDuplicate(): void
    {
        $skipped = [
            'de' => ['tos#:#x' => ['common: x', 'pilot: X'], 'tos#:#y' => ['mme: y']],
            'en' => ['tos#:#z' => ['mme: z']],
            'fr' => ['tos#:#z' => ['mme: z']],
        ];
        $activity = new LanguageActivityInvalidMarkupTestDouble(
            $this->rbacOf($this->createStub(\ilRbacSystem::class)),
            $this->languageFolder()
        );
 
        $this->assertSame(
            ['en: tos#:#z (mme: z)', 'de: tos#:#x (common: x, pilot: X)', 'de: tos#:#y (mme: y)'],
            $activity->duplicateEntries($skipped, ['en', 'de', 'it'])
        );
    }
}
 
final class LanguageActivityThrowingInputDescriptionTestDouble extends LanguageActivity
{
    public function __construct(
        RBAC $rbac,
        LanguageFolder $language_folder,
        private readonly bool $throw_type_error = false,
    ) {
        parent::__construct($rbac, $language_folder);
    }
 
    public function getDescription(): Text\SimpleDocumentMarkdown
    {
        return $this->data->text()->markdown()->simpleDocument('Test double for LanguageActivity::maybePerformAs().');
    }
 
    public function getInputDescription(FieldFactory $f): FormInput
    {
        if ($this->throw_type_error) {
            throw new \TypeError('simulated TypeError while building the input description');
        }
 
        throw new \RuntimeException('simulated failure while building the input description');
    }
 
    public function getOutputDescription(Description\Factory $f): Description\Description
    {
        throw new \LogicException(__METHOD__ . ' is not used by this test double.');
    }
 
    public function perform(mixed $parameters): mixed
    {
        throw new \LogicException(__METHOD__ . ' is not used by this test double.');
    }
 
    protected function normalizeParameters(array $grind_result): array
    {
        throw new \LogicException(__METHOD__ . ' is not used by this test double.');
    }
}
 
final class LanguageActivityPerformEchoTestDouble extends LanguageActivity
{
    public function __construct(
        RBAC $rbac,
        LanguageFolder $language_folder,
        private readonly ?FormInput $description = null,
    ) {
        parent::__construct($rbac, $language_folder);
    }
 
    public function getDescription(): Text\SimpleDocumentMarkdown
    {
        return $this->data->text()->markdown()->simpleDocument('Test double for the usr_id precedence in maybePerformAs().');
    }
 
    public function getInputDescription(FieldFactory $f): FormInput
    {
        return $this->description ?? $f->group([]);
    }
 
    public function getOutputDescription(Description\Factory $f): Description\Description
    {
        throw new \LogicException(__METHOD__ . ' is not used by this test double.');
    }
 
    public function perform(mixed $parameters): mixed
    {
        return $parameters;
    }
 
    protected function normalizeParameters(array $grind_result): array
    {
        // spoofed 'usr_id' that must lose against the one maybePerformAs() passes
        return ['usr_id' => 'SPOOFED-VALUE', 'source' => 'form'];
    }
}
 
final class LanguageActivityInvalidMarkupTestDouble extends LanguageActivity
{
    public function entries(array $skipped, array $language_keys): array
    {
        return $this->invalidMarkupCustomizingEntries($skipped, $language_keys);
    }
 
    public function duplicateEntries(array $skipped, array $language_keys): array
    {
        return $this->duplicateCustomizingEntries($skipped, $language_keys);
    }
 
    public function getDescription(): Text\SimpleDocumentMarkdown
    {
        return $this->data->text()->markdown()->simpleDocument('Test double for invalidMarkupCustomizingEntries().');
    }
 
    public function getInputDescription(FieldFactory $f): FormInput
    {
        throw new \LogicException(__METHOD__ . ' is not used by this test double.');
    }
 
    public function getOutputDescription(Description\Factory $f): Description\Description
    {
        throw new \LogicException(__METHOD__ . ' is not used by this test double.');
    }
 
    public function perform(mixed $parameters): mixed
    {
        throw new \LogicException(__METHOD__ . ' is not used by this test double.');
    }
 
    protected function normalizeParameters(array $grind_result): array
    {
        throw new \LogicException(__METHOD__ . ' is not used by this test double.');
    }
}