SetLanguageTranslationEnabledTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\Language\Tests\Activities;
 
use ILIAS\Language\Tests\Activities\ActivityContractTestCase;
use ILIAS\Language\Activities\InvalidInputException;
use ILIAS\Language\Activities\SetLanguageTranslationEnabled;
use ILIAS\UI\Component\Input\Field\Text;
use ILIAS\UI\Component\Input\Field\Checkbox;
use ILIAS\Language\Activities\RepositoryProvider;
use ILIAS\Data\Description\Factory as DescriptionFactory;
use ILIAS\UI\Component\Input\Factory as InputFactory;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\MockObject\MockObject;
 
class SetLanguageTranslationEnabledTest extends ActivityContractTestCase
{
    protected function createDefaultActivity(): SetLanguageTranslationEnabled
    {
        return $this->createActivity();
    }
 
    public function testIsAllowedToPerformDelegatesToRbacSystemWithWriteAndTheConfiguredRefId(): void
    {
        $rbac = $this->createMock(\ilRbacSystem::class);
        $rbac->expects($this->once())
            ->method('checkAccessOfUser')
            ->with(6, 'write', 42)
            ->willReturn(true);
 
        $activity = $this->createActivity(rbac_system: $rbac, language_folder_ref_id: 42);
 
        $this->assertTrue($activity->isAllowedToPerform(6, ['language_key' => 'de', 'enabled' => true]));
    }
 
    public function testIsAllowedToPerformReturnsFalseWhenRbacDenies(): void
    {
        $rbac = $this->createStub(\ilRbacSystem::class);
        $rbac->method('checkAccessOfUser')->willReturn(false);
 
        $activity = $this->createActivity(rbac_system: $rbac);
 
        $this->assertFalse($activity->isAllowedToPerform(6, ['language_key' => 'de', 'enabled' => true]));
    }
 
    public function testIsAllowedToPerformNeverTouchesSettings(): void
    {
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->expects($this->never())->method('isPageTranslationEnabled');
        $repository->expects($this->never())->method('setPageTranslationEnabled');
 
        $rbac = $this->createStub(\ilRbacSystem::class);
        $rbac->method('checkAccessOfUser')->willReturn(true);
 
        $activity = $this->createActivity(rbac_system: $rbac, repository: $repository);
 
        $this->assertTrue($activity->isAllowedToPerform(6, ['language_key' => 'de', 'enabled' => true]));
    }
 
    public static function performChangedDecisionProvider(): array
    {
        return [
            'stored off, request on -> changed, write on' => [false, true, true, true],
            'stored off, request off -> unchanged, no write' => [false, false, false, null],
            'stored on, request on -> unchanged, no write' => [true, true, false, null],
            'stored on, request off -> changed, write off' => [true, false, true, false],
        ];
    }
 
    #[DataProvider('performChangedDecisionProvider')]
    public function testPerformWritesOnlyWhenTheRequestedValueDiffersFromTheStoredOne(
        bool $stored_value,
        bool $requested_enabled,
        bool $expected_changed,
        ?bool $expected_written_value
    ): void {
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->expects($this->once())->method('isPageTranslationEnabled')
            ->with('de')
            ->willReturn($stored_value);
 
        if ($expected_written_value === null) {
            $repository->expects($this->never())->method('setPageTranslationEnabled');
        } else {
            $repository->expects($this->once())
                ->method('setPageTranslationEnabled')
                ->with('de', $expected_written_value);
        }
 
        $result = $this->createActivity(repository: $repository)
            ->perform(['language_key' => 'de', 'enabled' => $requested_enabled]);
 
        $this->assertSame(
            ['language_key' => 'de', 'enabled' => $requested_enabled, 'changed' => $expected_changed],
            $result
        );
    }
 
    public function testPerformReadsTheCorrectPerLanguageSettingKeyWithDefaultZero(): void
    {
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->expects($this->once())
            ->method('isPageTranslationEnabled')->with('fr')->willReturn(false);
 
        $this->createActivity(repository: $repository)->perform(['language_key' => 'fr', 'enabled' => false]);
    }
 
    public function testPerformTrimsLanguageKeyForBothTheSettingKeyAndTheReturnedValue(): void
    {
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->expects($this->once())->method('isPageTranslationEnabled')->with('de')->willReturn(false);
        $repository->expects($this->once())->method('setPageTranslationEnabled')->with('de', true);
 
        $result = $this->createActivity(repository: $repository)
            ->perform(['language_key' => '  de  ', 'enabled' => true]);
 
        $this->assertSame('de', $result['language_key']);
    }
 
    public static function invalidPerformParametersProvider(): array
    {
        return [
            'non-array parameters' => ['not-an-array'],
            'empty array' => [[]],
            'missing language_key' => [['enabled' => true]],
            'non-string language_key' => [['language_key' => 42, 'enabled' => true]],
            'empty string language_key' => [['language_key' => '', 'enabled' => true]],
            'whitespace-only language_key' => [['language_key' => '   ', 'enabled' => true]],
            'missing enabled' => [['language_key' => 'de']],
            'non-bool enabled: string "1"' => [['language_key' => 'de', 'enabled' => '1']],
            'non-bool enabled: string "true"' => [['language_key' => 'de', 'enabled' => 'true']],
            'non-bool enabled: string ""' => [['language_key' => 'de', 'enabled' => '']],
            'non-bool enabled: int 1' => [['language_key' => 'de', 'enabled' => 1]],
            'non-bool enabled: int 0' => [['language_key' => 'de', 'enabled' => 0]],
            'non-bool enabled: float 1.0' => [['language_key' => 'de', 'enabled' => 1.0]],
            'non-bool enabled: null' => [['language_key' => 'de', 'enabled' => null]],
            'non-bool enabled: array' => [['language_key' => 'de', 'enabled' => [true]]],
        ];
    }
 
    #[DataProvider('invalidPerformParametersProvider')]
    public function testPerformRejectsInvalidOrIncompleteParametersWithoutTouchingSettings(mixed $parameters): void
    {
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->expects($this->never())->method('isPageTranslationEnabled');
        $repository->expects($this->never())->method('setPageTranslationEnabled');
 
        $this->expectException(InvalidInputException::class);
 
        $this->createActivity(repository: $repository)->perform($parameters);
    }
 
    public function testMaybePerformAsWithGrantedPermissionPerformsAndReturnsOkResult(): void
    {
        $rbac = $this->createStub(\ilRbacSystem::class);
        $rbac->method('checkAccessOfUser')->willReturn(true);
 
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->expects($this->once())->method('isPageTranslationEnabled')->with('de')->willReturn(false);
        $repository->expects($this->once())->method('setPageTranslationEnabled')->with('de', true);
 
        $result = $this->createActivity(rbac_system: $rbac, repository: $repository)
            ->maybePerformAs($this->createRealFieldsUiFactory()->input(), 6, ['language_key' => 'de', 'enabled' => true]);
 
        $this->assertFalse($result->isError());
        $this->assertSame(
            ['language_key' => 'de', 'enabled' => true, 'changed' => true],
            $result->value()
        );
    }
 
    public function testMaybePerformAsWithDeniedPermissionReturnsErrorAndNeverTouchesSettings(): void
    {
        $rbac = $this->createMock(\ilRbacSystem::class);
        $rbac->expects($this->once())
            ->method('checkAccessOfUser')
            ->with(6, 'write', $this->anything())
            ->willReturn(false);
 
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->expects($this->never())->method('isPageTranslationEnabled');
        $repository->expects($this->never())->method('setPageTranslationEnabled');
 
        $result = $this->createActivity(rbac_system: $rbac, repository: $repository)
            ->maybePerformAs($this->createRealFieldsUiFactory()->input(), 6, ['language_key' => 'de', 'enabled' => true]);
 
        $this->assertTrue($result->isError());
        $this->assertInstanceOf(\DomainException::class, $result->error());
        $this->assertSame(403, $result->error()->getCode());
    }
 
    public function testDefectFromWithinPerformIsMaskedAsA500ResultError(): void
    {
        $rbac = $this->createStub(\ilRbacSystem::class);
        $rbac->method('checkAccessOfUser')->willReturn(true);
 
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->method('isPageTranslationEnabled')->willReturn(false);
        $repository->method('setPageTranslationEnabled')->willThrowException(new \RuntimeException('database write failed'));
 
        $result = $this->createActivity(rbac_system: $rbac, repository: $repository)
            ->maybePerformAs($this->createRealFieldsUiFactory()->input(), 6, ['language_key' => 'de', 'enabled' => true]);
 
        $this->assertTrue($result->isError());
        $error = $result->error();
        $this->assertSame(500, $error->getCode());
        $this->assertSame('database write failed', $error->getPrevious()?->getMessage());
    }
 
    public function testMaybePerformAsWithMissingRawParametersKeysIsAResultErrorAndNeverChecksPermission(): void
    {
        $rbac = $this->createMock(\ilRbacSystem::class);
        $rbac->expects($this->never())->method('checkAccessOfUser');
 
        $result = $this->createActivity(rbac_system: $rbac)->maybePerformAs($this->createRealFieldsUiFactory()->input(), 6, []);
 
        $this->assertTrue($result->isError());
        $this->assertInstanceOf(InvalidInputException::class, $result->error());
        $this->assertNotSame('', $result->error()->getMessage());
    }
 
    public static function invalidRawParametersRejectedByGrindWithStringErrorProvider(): array
    {
        return [
            'missing language_key' => [['enabled' => true]],
        ];
    }
 
    #[DataProvider('invalidRawParametersRejectedByGrindWithStringErrorProvider')]
    public function testMaybePerformAsRejectsRawParametersAtGrindLevelWithStringErrorWithoutTouchingSettingsOrRbac(
        array $raw_parameters
    ): void {
        $rbac = $this->createMock(\ilRbacSystem::class);
        $rbac->expects($this->never())->method('checkAccessOfUser');
 
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->expects($this->never())->method('isPageTranslationEnabled');
        $repository->expects($this->never())->method('setPageTranslationEnabled');
 
        $result = $this->createActivity(rbac_system: $rbac, repository: $repository)
            ->maybePerformAs($this->createRealFieldsUiFactory()->input(), 6, $raw_parameters);
 
        $this->assertTrue($result->isError());
        $this->assertInstanceOf(InvalidInputException::class, $result->error());
        $this->assertNotSame('', $result->error()->getMessage());
    }
 
    public static function invalidRawParametersProvider(): array
    {
        return [
            // a non-string 'language_key' fails the Text field's isClientSideValueOk() inside grind()
            'non-string language_key' => [['language_key' => 42, 'enabled' => true]],
            // outside the whitelist of GrindsFormInput::normalizeCheckboxRawValue()
            'non-bool enabled: array' => [['language_key' => 'de', 'enabled' => [true]]],
            'non-bool enabled: float 1.0' => [['language_key' => 'de', 'enabled' => 1.0]],
        ];
    }
 
    #[DataProvider('invalidRawParametersProvider')]
    public function testMaybePerformAsRejectsInvalidRawParametersAsResultErrorWithoutTouchingSettingsOrRbac(
        array $raw_parameters
    ): void {
        $rbac = $this->createMock(\ilRbacSystem::class);
        $rbac->expects($this->never())->method('checkAccessOfUser');
 
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->expects($this->never())->method('isPageTranslationEnabled');
        $repository->expects($this->never())->method('setPageTranslationEnabled');
 
        $result = $this->createActivity(rbac_system: $rbac, repository: $repository)
            ->maybePerformAs($this->createRealFieldsUiFactory()->input(), 6, $raw_parameters);
 
        $this->assertTrue($result->isError());
        $this->assertInstanceOf(InvalidInputException::class, $result->error());
        $this->assertSame(400, $result->error()->getCode());
    }
 
    public function testMaybePerformAsWithMissingEnabledKeyDefaultsToFalseAndStillPerformsTheWrite(): void
    {
        $rbac = $this->createMock(\ilRbacSystem::class);
        $rbac->expects($this->once())->method('checkAccessOfUser')->willReturn(true);
 
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->expects($this->once())->method('isPageTranslationEnabled')->with('de')->willReturn(true);
        $repository->expects($this->once())->method('setPageTranslationEnabled')->with('de', false);
 
        $result = $this->createActivity(rbac_system: $rbac, repository: $repository)
            ->maybePerformAs($this->createRealFieldsUiFactory()->input(), 6, ['language_key' => 'de']);
 
        $this->assertFalse($result->isError());
        $this->assertSame(
            ['language_key' => 'de', 'enabled' => false, 'changed' => true],
            $result->value()
        );
    }
 
    public function testMaybePerformAsRejectsWhitespaceOnlyLanguageKeyAfterThePermissionCheck(): void
    {
        $rbac = $this->createMock(\ilRbacSystem::class);
        $rbac->expects($this->once())->method('checkAccessOfUser')->willReturn(true);
 
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->expects($this->never())->method('isPageTranslationEnabled');
        $repository->expects($this->never())->method('setPageTranslationEnabled');
 
        $result = $this->createActivity(rbac_system: $rbac, repository: $repository)
            ->maybePerformAs($this->createRealFieldsUiFactory()->input(), 6, ['language_key' => '   ', 'enabled' => true]);
 
        $this->assertTrue($result->isError());
        $this->assertInstanceOf(InvalidInputException::class, $result->error());
        $this->assertSame(400, $result->error()->getCode());
    }
 
    public static function tolerantlyAcceptedTruthyEnabledValuesProvider(): array
    {
        return [
            'string "1"' => ['1'],
            'string "true"' => ['true'],
            'int 1' => [1],
        ];
    }
 
    public static function tolerantlyAcceptedFalsyEnabledValuesProvider(): array
    {
        return [
            'string "0"' => ['0'],
            'string "false"' => ['false'],
            'string ""' => [''],
            'int 0' => [0],
            'null' => [null],
        ];
    }
 
    #[DataProvider('tolerantlyAcceptedTruthyEnabledValuesProvider')]
    public function testMaybePerformAsToleratesCommonPrimitiveTruthyEnabledRepresentations(mixed $value): void
    {
        $rbac = $this->createStub(\ilRbacSystem::class);
        $rbac->method('checkAccessOfUser')->willReturn(true);
 
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->expects($this->once())->method('isPageTranslationEnabled')->with('de')->willReturn(false);
        $repository->expects($this->once())->method('setPageTranslationEnabled')->with('de', true);
 
        $result = $this->createActivity(rbac_system: $rbac, repository: $repository)
            ->maybePerformAs($this->createRealFieldsUiFactory()->input(), 6, ['language_key' => 'de', 'enabled' => $value]);
 
        $this->assertFalse($result->isError());
        $this->assertSame(
            ['language_key' => 'de', 'enabled' => true, 'changed' => true],
            $result->value()
        );
    }
 
    #[DataProvider('tolerantlyAcceptedFalsyEnabledValuesProvider')]
    public function testMaybePerformAsToleratesCommonPrimitiveFalsyEnabledRepresentations(mixed $value): void
    {
        $rbac = $this->createStub(\ilRbacSystem::class);
        $rbac->method('checkAccessOfUser')->willReturn(true);
 
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->expects($this->once())->method('isPageTranslationEnabled')->with('de')->willReturn(true);
        $repository->expects($this->once())->method('setPageTranslationEnabled')->with('de', false);
 
        $result = $this->createActivity(rbac_system: $rbac, repository: $repository)
            ->maybePerformAs($this->createRealFieldsUiFactory()->input(), 6, ['language_key' => 'de', 'enabled' => $value]);
 
        $this->assertFalse($result->isError());
        $this->assertSame(
            ['language_key' => 'de', 'enabled' => false, 'changed' => true],
            $result->value()
        );
    }
 
    public function testPerformRejectsUnknownLanguageKeyWithoutTouchingSettings(): void
    {
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->expects($this->never())->method('isPageTranslationEnabled');
        $repository->expects($this->never())->method('setPageTranslationEnabled');
 
        $this->expectException(InvalidInputException::class);
 
        $this->createActivity(repository: $repository)
            ->perform(['language_key' => 'xx', 'enabled' => true]);
    }
 
    public function testPerformRejectsUnknownLanguageKeyMessageContainsTheRawUnescapedKey(): void
    {
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->expects($this->never())->method('isPageTranslationEnabled');
        $repository->expects($this->never())->method('setPageTranslationEnabled');
 
        $dangerous_key = '<script>alert(1)</script>&"quoted"';
 
        try {
            $this->createActivity(repository: $repository)
                ->perform(['language_key' => $dangerous_key, 'enabled' => true]);
            $this->fail('Expected an InvalidInputException to be thrown.');
        } catch (InvalidInputException $e) {
            $this->assertStringContainsString($dangerous_key, $e->getMessage());
            $this->assertStringNotContainsString('&lt;script&gt;', $e->getMessage());
            $this->assertStringNotContainsString('&quot;', $e->getMessage());
        }
    }
 
    public function testMaybePerformAsRejectsUnknownLanguageKeyAfterPermissionCheckAndNeverTouchesSettings(): void
    {
        $rbac = $this->createMock(\ilRbacSystem::class);
        $rbac->expects($this->once())->method('checkAccessOfUser')->willReturn(true);
 
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->expects($this->never())->method('isPageTranslationEnabled');
        $repository->expects($this->never())->method('setPageTranslationEnabled');
 
        $result = $this->createActivity(rbac_system: $rbac, repository: $repository)
            ->maybePerformAs($this->createRealFieldsUiFactory()->input(), 6, ['language_key' => 'xx', 'enabled' => true]);
 
        $this->assertTrue($result->isError());
        $this->assertInstanceOf(InvalidInputException::class, $result->error());
        $this->assertSame(400, $result->error()->getCode());
    }
 
    public function testMaybePerformAsTrimsLanguageKeyBeforeBuildingTheSettingKey(): void
    {
        $rbac = $this->createStub(\ilRbacSystem::class);
        $rbac->method('checkAccessOfUser')->willReturn(true);
 
        $repository = $this->createMock(RepositoryProvider::class);
        $repository->expects($this->once())->method('isPageTranslationEnabled')->with('de')->willReturn(false);
        $repository->expects($this->once())->method('setPageTranslationEnabled')->with('de', true);
 
        $result = $this->createActivity(rbac_system: $rbac, repository: $repository)
            ->maybePerformAs($this->createRealFieldsUiFactory()->input(), 6, ['language_key' => '  de  ', 'enabled' => true]);
 
        $this->assertFalse($result->isError());
        $this->assertSame('de', $result->value()['language_key']);
    }
 
    public function testInputDescriptionBuildsAGroupWithARequiredLanguageKeyTextFieldAndAnEnabledCheckbox(): void
    {
        $text = $this->createMock(Text::class);
        $text->expects($this->once())->method('withRequired')->with(true)->willReturnSelf();
        $text->expects($this->once())->method('withDedicatedName')->with('language_key')->willReturnSelf();
 
        $checkbox = $this->createMock(Checkbox::class);
        $checkbox->expects($this->once())
            ->method('withDedicatedName')
            ->with('enabled')
            ->willReturnSelf();
 
        $field = $this->createMock(\ILIAS\UI\Component\Input\Field\Factory::class);
        $field->expects($this->once())
            ->method('text')
            ->with(
                'Language key',
                'Language key the page translation setting applies to, e.g. de, fr, it.'
            )
            ->willReturn($text);
        $field->expects($this->once())
            ->method('checkbox')
            ->with(
                'Enabled',
                'Whether page translation should be enabled for this language.'
            )
            ->willReturn($checkbox);
 
        $group = $this->createMock(\ILIAS\UI\Component\Input\Field\Section::class);
        $field->expects($this->once())
            ->method('section')
            ->with(['language_key' => $text, 'enabled' => $checkbox], $this->anything())
            ->willReturn($group);
 
        $activity = $this->createActivity();
 
        $this->assertSame($group, $activity->getInputDescription($field));
    }
 
    public function testOutputDescriptionDescribesTheThreeDocumentedFieldsInOrder(): void
    {
        $activity = $this->createActivity();
 
        $description = $activity->getOutputDescription(new DescriptionFactory());
 
        $field_names = [];
        foreach ($description->getFields() as $field) {
            $field_names[] = $field->getName();
        }
 
        $this->assertSame(['language_key', 'enabled', 'changed'], $field_names);
    }
 
    private function createActivity(
        ?\ilRbacSystem $rbac_system = null,
        (RepositoryProvider&MockObject)|null $repository = null,
        int $language_folder_ref_id = 0,
        array $installed_languages = ['de', 'fr'],
    ): SetLanguageTranslationEnabled {
        $repository ??= $this->createMock(RepositoryProvider::class);
        $repository->method('getInstalledLanguages')->willReturn($installed_languages);
 
        return new SetLanguageTranslationEnabled(
            $this->rbacOf($rbac_system ?? $this->createMock(\ilRbacSystem::class)),
            $this->languageFolder($language_folder_ref_id),
            $repository,
        );
    }
}