MigratedLanguageFileSyncGuardsTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
use ILIAS\Language\ComponentTranslation\CustomizingLanguageFileDirectory;
use ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog;
use ILIAS\Language\ComponentTranslation\LanguageFileDirectory;
use ILIAS\Language\ComponentTranslation\LanguageFileDirectoryManager;
use ILIAS\Language\ComponentTranslation\LocalChangeComments;
use ILIAS\Language\ComponentTranslation\MainLanguageFileDirectory;
use ILIAS\Language\ComponentTranslation\MigratedLanguageFileSync;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
 
class MigratedLanguageFileSyncGuardsTest extends MigratedLanguageFileSyncTestCase
{
    public function testIsANoOpWhenTheModuleHasNoContributedDirectory(): void
    {
        $this->seedShipped(['greeting' => 'Hallo']);
 
        MigratedLanguageFileSync::sync($this->manager, $this->ilias_root, 'de', 'other_module', ['x' => 'y'], $this->client_data_dir);
        MigratedLanguageFileSync::sync($this->manager, $this->ilias_root, 'de', '', ['x' => 'y'], $this->client_data_dir, true);
 
        $this->assertDirectoryDoesNotExist($this->client_data_dir . '/lang');
    }
 
    public function testIsANoOpWhenNoShippedPoExistsForTheLanguage(): void
    {
        $this->seedShipped(['greeting' => 'Hello'], 'en');
 
        $this->sync(['greeting' => 'Hallo'], true);
 
        $this->assertDirectoryDoesNotExist($this->client_data_dir . '/lang');
    }
 
    public function testAnExistingOverlayIsLeftUntouchedWhenTheShippedPoNoLongerExists(): void
    {
        $this->seedShipped(['greeting' => 'Hello']);
        $this->seedOverlay(['greeting' => 'Hallo']);
        $po_before = file_get_contents($this->overlayBase() . '.po');
        $mo_before = file_get_contents(MigratedPoFixture::overlayMo($this->overlayBase()));
        unlink($this->shippedPo());
 
        $this->sync(['greeting' => 'Hallo']);
 
        $this->assertSame($po_before, file_get_contents($this->overlayBase() . '.po'));
        $this->assertSame($mo_before, file_get_contents(MigratedPoFixture::overlayMo($this->overlayBase())));
    }
 
    public function testReadersIgnoreAnExistingOverlayWhileTheShippedPoIsMissing(): void
    {
        $this->seedShipped(['greeting' => 'Hello']);
        $this->seedOverlay(['greeting' => 'Hallo']);
        unlink($this->shippedPo());
 
        $this->assertNull(MigratedLanguageFileSync::loadModuleTranslations(
            $this->manager,
            'de',
            self::MODULE,
            $this->client_data_dir,
            $this->ilias_root
        ));
        $this->assertSame(
            [],
            MigratedLanguageFileSync::getMigratedModules($this->manager, 'de', $this->client_data_dir, $this->ilias_root)
        );
    }
 
    public function testARefreshAfterTheShippedPoComesBackStillMovesTheOriginalForwardCorrectly(): void
    {
        $this->seedShipped(['greeting' => 'Hello']);
        // the "original" of this local change must survive the whole gap below untouched
        $this->seedOverlay(['greeting' => ['value' => 'Hallo', 'original' => 'Hello', 'local_change' => '2020-01-01T00:00:00Z']]);
        unlink($this->shippedPo());
 
        // asserted here so a regression touching the overlay's "original"/local_change bookkeeping while the `.po` is
        // missing fails here, not only once it is back ($refresh_original_from_shipped would then mask the loss)
        $this->sync(['greeting' => 'Hallo']);
        // untouched, so still as seeded: with the module as msgctxt
        $preserved_during_the_gap = $this->overlayPo()->find(self::MODULE, 'greeting');
        $this->assertSame('Hello', LocalChangeComments::getOriginal($preserved_during_the_gap), 'original survives the gap');
        $this->assertSame('2020-01-01T00:00:00Z', LocalChangeComments::getLocalChange($preserved_during_the_gap));
 
        // the module is migrated again - the shipped `.po` is back, with a changed value
        $this->seedShipped(['greeting' => 'Servus']);
 
        // an unmodified local value ("Hallo" is still tracked against the preserved original
        // "Hello") is refreshed to the new shipped value, exactly like an ordinary update
        $this->sync(['greeting' => 'Servus'], true);
 
        // the value is now the shipped one: served from the shipped .po, the overlay is removed
        $this->assertFileDoesNotExist($this->overlayBase() . '.po');
        $this->assertSame(
            ['value' => 'Servus', 'local_change' => false, 'local_change_date' => null, 'original' => 'Servus'],
            MigratedLanguageFileSync::loadModuleTranslations($this->manager, 'de', self::MODULE, $this->client_data_dir)['greeting']
        );
    }
 
    public function testIsANoOpWhenTheClientDataDirIsNull(): void
    {
        $this->seedShipped(['greeting' => 'Hallo']);
        $shipped_before = file_get_contents($this->shippedPo());
 
        $this->sync(['greeting' => 'Servus'], true, null);
 
        $this->assertSame($shipped_before, file_get_contents($this->shippedPo()));
        $this->assertSame(['stest_de.po'], array_values(array_diff(scandir($this->fixture_directory), ['.', '..'])));
    }
 
    #[DataProvider('refreshFlags')]
    public function testACorruptOverlayPoIsRebuiltFromEntriesAndTheShippedPo(bool $refresh): void
    {
        $this->seedShipped(['greeting' => 'Hallo', 'farewell' => 'Tschüss']);
        $this->seedOverlay(['greeting' => ['value' => 'Hallo', 'original' => 'Hallo']]);
        file_put_contents($this->overlayBase() . '.po', "msgid \"broken\nmsgstr \"\"\n");
 
        $this->sync(['greeting' => 'Hallo', 'farewell' => 'Servus'], $refresh);
 
        // "greeting" carries the shipped value and is not written
        $overlay = $this->overlayPo();
        $this->assertSame(['farewell'], $this->overlayIdentifiers());
        $farewell = $overlay->find(null, 'farewell');
        $this->assertSame('Tschüss', LocalChangeComments::getOriginal($farewell));
        $this->assertNotNull(LocalChangeComments::getLocalChange($farewell));
        $this->assertSame(['farewell' => 'Servus'], MigratedPoFixture::readMo(MigratedPoFixture::overlayMo($this->overlayBase())));
    }
 
    #[DataProvider('overlaysOnlyAStrictParserRejects')]
    public function testAnOverlayPoTheStrictParserRejectsIsRebuilt(string $content): void
    {
        $this->seedShipped(['greeting' => 'Hallo']);
        $this->seedOverlay(['greeting' => ['value' => 'Hallo', 'original' => 'Hallo']]);
        file_put_contents($this->overlayBase() . '.po', $content);
 
        $this->sync(['greeting' => 'Servus']);
 
        $greeting = $this->overlayPo()->find(null, 'greeting');
        $this->assertSame('Servus', $greeting?->getTranslation());
        $this->assertSame('Hallo', LocalChangeComments::getOriginal($greeting));
        $this->assertNotNull(LocalChangeComments::getLocalChange($greeting));
        $this->assertSame(['greeting' => 'Servus'], MigratedPoFixture::readMo(MigratedPoFixture::overlayMo($this->overlayBase())));
    }
 
    public static function overlaysOnlyAStrictParserRejects(): array
    {
        $message = "msgctxt \"" . self::MODULE . "\"\nmsgid \"greeting\"\nmsgstr \"Hallo\"\n";
 
        return [
            'duplicate message' => [$message . "\n" . $message],
            'message without msgstr' => ["msgctxt \"" . self::MODULE . "\"\nmsgid \"greeting\"\n"],
            'truncated inside a string' => [substr($message, 0, -4)],
            'gap in the plural forms' => ["msgid \"a\"\nmsgid_plural \"as\"\nmsgstr[0] \"x\"\nmsgstr[2] \"z\"\n"],
            'binary data' => ["\x00\x01\x02\xde\x12\x04\x95"],
            'header value with a line break' => ["msgid \"\"\nmsgstr \"\"\n\"X-A: a\\rb\\n\"\n\n" . $message],
        ];
    }
 
    public function testACorruptShippedPoThrows(): void
    {
        file_put_contents($this->shippedPo(), "msgid \"broken\n");
 
        $this->expectException(RuntimeException::class);
        $this->sync(['greeting' => 'Hallo']);
    }
 
    public function testAShippedPoWithALineBreakInAHeaderValueThrowsARuntimeExceptionAndWritesNothing(): void
    {
        file_put_contents(
            $this->shippedPo(),
            "msgid \"\"\nmsgstr \"\"\n\"X-A: a\\rb\\n\"\n\nmsgctxt \"" . self::MODULE . "\"\nmsgid \"greeting\"\nmsgstr \"Hallo\"\n"
        );
 
        try {
            $this->sync(['greeting' => 'Hallo']);
            $this->fail('Expected a RuntimeException');
        } catch (RuntimeException $e) {
            $this->assertStringContainsString('contains a line break', $e->getMessage());
        }
 
        $this->assertFileDoesNotExist($this->overlayBase() . '.po');
        $this->assertFileDoesNotExist(MigratedPoFixture::overlayMo($this->overlayBase()));
    }
 
    public function testThrowsWhenTheOverlayDirectoryCannotBeCreated(): void
    {
        $this->seedShipped(['greeting' => 'Hallo']);
        file_put_contents($this->client_data_dir . '/lang', 'not a directory');
 
        set_error_handler(static fn(): bool => true, E_WARNING);
        try {
            $this->expectException(RuntimeException::class);
            $this->expectExceptionMessageMatches('/Could not create directory/');
            $this->sync(['greeting' => 'Servus']);
        } finally {
            restore_error_handler();
        }
    }
 
    public function testAcquireLockLogsAWarningWhenTheLockFileCannotBeOpenedButTheWriteStillSucceeds(): void
    {
        if (function_exists('posix_geteuid') && posix_geteuid() === 0) {
            $this->markTestSkipped('An unopenable file cannot be forced for root.');
        }
        $this->seedShipped(['greeting' => 'Hallo']);
        // a first sync creates the lock file (and the overlay) so its own permission can be revoked
        $this->sync(['greeting' => 'Servus']);
        $lock_file = MigratedPoFixture::overlayLock($this->overlayBase());
        $this->assertFileExists($lock_file);
        chmod($lock_file, 0000);
 
        $this->expectErrorLog();
        $this->sync(['greeting' => 'Nochmal geändert']);
 
        $this->assertStringContainsString('Could not open the lock file', $this->errorLog());
        $this->assertSame(['greeting' => 'Nochmal geändert'], MigratedPoFixture::readMo(MigratedPoFixture::overlayMo($this->overlayBase())));
    }
 
    private function errorLog(): string
    {
        $file = (string) ini_get('error_log');
        return $file !== '' && is_file($file) ? (string) file_get_contents($file) : '';
    }
 
    public function testThrowsWhenTheOverlayPoCannotBeReplacedAndLeavesNoTemporaryFile(): void
    {
        $this->seedShipped(['greeting' => 'Hallo']);
        mkdir($this->overlayBase() . '.po', 0775, true);
 
        set_error_handler(static fn(): bool => true, E_WARNING);
        try {
            $this->sync(['greeting' => 'Servus']);
            $this->fail('Expected a RuntimeException');
        } catch (RuntimeException $e) {
            // refused before any write is attempted: the .po path is no regular file
            $this->assertStringContainsString('no regular file', $e->getMessage());
        } finally {
            restore_error_handler();
        }
 
        $this->assertSame(
            // the lock file (see MigratedLanguageFileSync::withOverlayLock()) is never removed
            ['lock', 'stest_de.po'],
            array_values(array_diff(scandir(dirname($this->overlayBase())), ['.', '..'])),
            'neither a temporary file nor a .mo may be left behind'
        );
    }
 
    public function testWritesTheOverlayWhenTheClientDataDirIsASymlink(): void
    {
        $this->seedShipped(['greeting' => 'Hallo']);
        $link = $this->client_data_dir . '-link';
        symlink($this->client_data_dir, $link);
 
        try {
            MigratedLanguageFileSync::sync($this->manager, $this->ilias_root, 'de', self::MODULE, ['greeting' => 'Servus'], $link);
        } finally {
            unlink($link);
        }
 
        $this->assertSame(['greeting' => 'Servus'], MigratedPoFixture::readMo(MigratedPoFixture::overlayMo($this->overlayBase())));
    }
 
    public function testAnInstallationDoesNotDiscardAnOverlayCreatedConcurrentlyAfterItsDecision(): void
    {
        $this->seedShipped(['greeting' => 'Hallo']);
 
        // The concurrent admin edit completes first and creates a genuine local change.
        $this->sync(['greeting' => 'Servus']);
        $this->assertFileExists($this->overlayBase() . '.po', 'precondition: the admin edit created an overlay');
 
        // The installation's snapshot is from BEFORE that edit: no overlay, only the shipped value.
        try {
            MigratedLanguageFileSync::sync($this->manager, $this->ilias_root, 'de', self::MODULE, ['greeting' => 'Hallo'], $this->client_data_dir, true, false);
            $this->fail('Expected a RuntimeException');
        } catch (RuntimeException $e) {
            $this->assertStringContainsString('was created after', $e->getMessage());
        }
 
        $this->assertSame(['greeting' => 'Servus'], MigratedPoFixture::readMo(MigratedPoFixture::overlayMo($this->overlayBase())));
        $this->assertTrue(
            MigratedLanguageFileSync::loadModuleTranslations($this->manager, 'de', self::MODULE, $this->client_data_dir)['greeting']['local_change']
        );
    }
}