sync() computing the delta overlay: creation, admin edit, reconciling write (refresh), replace semantics. More...

Inheritance diagram for MigratedLanguageFileSyncDeltaTest:

Collaboration diagram for MigratedLanguageFileSyncDeltaTest:

Public Member Functions
	testSyncingOnlyShippedValuesWritesNoOverlay (bool $refresh)
	A module whose values are all shipped ones needs no overlay: neither file, lock nor directory is created, by an admin edit or a reconciling write. More...

	testCreatingTheOverlayWithADeviatingValueRecordsShippedOriginalAndALocalChange ()

	testCreatingTheOverlayGivesAnEntryWithoutShippedCounterpartNoOriginalButALocalChange ()

	testCreatingTheOverlayKeepsShippedFuzzyOnlyForTheUnchangedShippedValue ()
	A shipped "fuzzy" (an unreviewed value, usually the English fallback) must survive the very first sync as long as the value is still the shipped one - and must not be copied onto a value that differs from it. More...

	testTheDeltaIsComparedAgainstTheRawShippedValueNotTheMarkupCleanedOne ()
	The delta is compared against the RAW shipped `.po` value (TranslationCatalog::fromPoFile()), not the markup- cleaned value the build serves: a value with markup TranslationMarkupPolicy disallows is still the shipped value, so writing it back creates no delta. More...

	testTheOverlayTakesTheExtractedCommentsOfTheShippedEntry ()
	Extracted comments ("#. ...", context for translators) are part of the shipped file and are carried into the overlay on creation/refresh. More...

	testTheOverlayTakesTheHeadersOfTheShippedPo ()

	testAnAdminEditNeverMovesTheOriginal ()
	refresh = false (an ordinary admin edit): the baseline "original" must never move - even when the shipped file changed in the meantime. More...

	testAnAdminEditRemovesFuzzyOnlyFromTheValuesItActuallyChanges ()

	testWritingTheOriginalValueBackClearsTheLocalChange ()

	testTheLocalChangeTimestampOfAnUntouchedEntrySurvivesAnUnrelatedWrite ()
	A full-replace write re-sends every value; an entry whose value did not change must keep its existing local_change timestamp (seeded with a fixed, old value - no sleep()/clock needed). More...

	testALegacyEntryWithTheModuleAsMsgctxtIsMigratedToNoContextPreservingItsBookkeeping (bool $refresh)
	An overlay of an earlier version carried the module as msgctxt on every entry (see seedOverlay()); the next write must migrate it to the msgctxt-less shape (TranslationEntry::withContext(null)) while preserving translation, comments, flags, "local_change" and "original". More...

	testALegacyFullOverlayShrinksToTheDeltaOnTheNextReconcilingWrite ()
	An overlay written by the pre-delta design carried EVERY entry of the module. More...

	testRefreshMovesTheOriginalToTheNewShippedValueAndClearsTheLocalChangeOfAnUnmodifiedEntry ()

	testRefreshMovesTheOriginalButKeepsALocalCustomizationFlagged ()

	testRefreshKeepsTheOriginalOfAnEntryTheShippedPoNoLongerContains ()
	An entry the shipped `.po` no longer contains (kept by the caller as a real local change, see LanguageInstallationManager::resolveMigratedModule()) keeps its last "original" and its local_change date - so a later update can still tell it from an unchanged entry. More...

	testRefreshRecomputesFuzzyFromTheShippedEntry (array $shipped, array $overlay, string $value, ?bool $expected_fuzzy)
	On refresh fuzzy is recomputed from the shipped file: set exactly when the value is the shipped value and the shipped entry is fuzzy. More...

	testReplaceSemanticsRemoveEveryEntryThatIsNotPassed ()

	testSyncingNoEntriesRemovesTheOverlayButKeepsTheShippedFile ()
	An empty delta removes the overlay files - the shipped file and the lock file are kept. More...

	testEntriesOfAnotherContextInTheOldOverlayAreNotCarriedOver ()
	Entries of a different context (another module) are never taken over into this module's overlay: the overlay holds exactly $entries. More...

	testEntriesAreWrittenSortedByIdentifier ()
	Sorted byte-wise by identifier, independent of the order of $entries - keeps the file diff-stable. More...

Static Public Member Functions
static	refreshFlags ()

static	refreshFuzzyCases ()

static	refreshFlags ()

Additional Inherited Members
Protected Member Functions inherited from MigratedLanguageFileSyncTestCase
	setUp ()

	tearDown ()

	seedShipped (array $entries, string $lang_key='de', string $module=self::MODULE)

	seedOverlay (array $entries, string $lang_key='de')

	shippedPo (string $lang_key='de', string $module=self::MODULE)

	overlayBase (string $lang_key='de')

	overlayPo ()

	sync (array $entries, bool $refresh=false, ?string $client_data_dir='default')

	overlayIdentifiers ()

	overlayDirectory ()

	findUnwritable (array $lang_keys=['de'], ?string $client_data_dir='default', ?LanguageFileDirectoryManager $manager=null)

Protected Attributes inherited from MigratedLanguageFileSyncTestCase
const string	MODULE = 'stest'

string	$fixture_directory

string	$client_data_dir

string	$ilias_root

LanguageFileDirectory	$directory

LanguageFileDirectoryManager	$manager

Detailed Description

sync() computing the delta overlay: creation, admin edit, reconciling write (refresh), replace semantics.

Definition at line 34 of file MigratedLanguageFileSyncDeltaTest.php.

Member Function Documentation

◆ refreshFlags()

static MigratedLanguageFileSyncDeltaTest::refreshFlags ( )

static

Returns: array<string, array{0: bool}>

Reimplemented from MigratedLanguageFileSyncTestCase.

Definition at line 55 of file MigratedLanguageFileSyncDeltaTest.php.

                                         : array
    {
        return ['admin edit (refresh = false)' => [false], 'reconciling write (refresh = true)' => [true]];
    }

◆ refreshFuzzyCases()

static MigratedLanguageFileSyncDeltaTest::refreshFuzzyCases ( )

static

Returns: array<string, array<int, mixed>>

Definition at line 368 of file MigratedLanguageFileSyncDeltaTest.php.

                                              : array
    {
        return [
            'shipped fuzzy, value is shipped' => [
                ['value' => 'Hello', 'fuzzy' => true], ['value' => 'Hello', 'original' => 'Hello'], 'Hello', null,
            ],
            'shipped fuzzy, value differs' => [
                ['value' => 'Hello', 'fuzzy' => true], ['value' => 'Hallo', 'original' => 'Hello', 'fuzzy' => true], 'Hallo', false,
            ],
            'shipped reviewed now, overlay still fuzzy' => [
                ['value' => 'Hallo'], ['value' => 'Hallo', 'original' => 'Hello', 'fuzzy' => true], 'Hallo', null,
            ],
        ];
    }

◆ testALegacyEntryWithTheModuleAsMsgctxtIsMigratedToNoContextPreservingItsBookkeeping()

MigratedLanguageFileSyncDeltaTest::testALegacyEntryWithTheModuleAsMsgctxtIsMigratedToNoContextPreservingItsBookkeeping ( bool $refresh )

An overlay of an earlier version carried the module as msgctxt on every entry (see seedOverlay()); the next write must migrate it to the msgctxt-less shape (TranslationEntry::withContext(null)) while preserving translation, comments, flags, "local_change" and "original".

Definition at line 236 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                                                                      : void
    {
        $this->seedShipped(['greeting' => 'Hallo']);
        $legacy_overlay = MigratedPoFixture::catalog(self::MODULE, [
            'greeting' => ['value' => 'Servus', 'original' => 'Hallo', 'local_change' => '2020-01-01T00:00:00Z'],
        ]);
        $legacy_overlay->find(self::MODULE, 'greeting')->addExtractedComment('shown on the login page');
        MigratedPoFixture::writePair($this->overlayBase(), $legacy_overlay);
        $this->assertNotNull($this->overlayPo()->find(self::MODULE, 'greeting'), 'precondition: seeded with the module as msgctxt');
 
        // a genuine local change is kept alive by re-sending the exact same value
        $this->sync(['greeting' => 'Servus'], $refresh);
 
        $this->assertNull($this->overlayPo()->find(self::MODULE, 'greeting'), 'no longer stored under the module context');
        $migrated = $this->overlayPo()->find(null, 'greeting');
        $this->assertNotNull($migrated);
        $this->assertSame('Servus', $migrated->getTranslation());
        $this->assertSame('Hallo', LocalChangeComments::getOriginal($migrated));
        $this->assertSame('2020-01-01T00:00:00Z', LocalChangeComments::getLocalChange($migrated));
        if (!$refresh) {
            // refresh=true re-baselines extracted comments from the shipped entry (which has none
            // here) - only an ordinary admin edit (refresh=false) keeps the overlay's own comment
            $this->assertSame(['shown on the login page'], $migrated->getExtractedComments());
        }
    }

References MigratedPoFixture\catalog(), MigratedLanguageFileSyncTestCase\overlayBase(), MigratedLanguageFileSyncTestCase\overlayPo(), MigratedLanguageFileSyncTestCase\seedShipped(), MigratedLanguageFileSyncTestCase\sync(), and MigratedPoFixture\writePair().

Here is the call graph for this function:

◆ testALegacyFullOverlayShrinksToTheDeltaOnTheNextReconcilingWrite()

MigratedLanguageFileSyncDeltaTest::testALegacyFullOverlayShrinksToTheDeltaOnTheNextReconcilingWrite ( )

An overlay written by the pre-delta design carried EVERY entry of the module.

The next reconciling write (Setup update) must shrink it to the true delta in one sync(): entries equal to the shipped value without local_change are dropped, a genuine local change survives - no dedicated migration step.

Definition at line 267 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                                      : void
    {
        $this->seedShipped(['unchanged_one' => 'A', 'unchanged_two' => 'B', 'changed' => 'C']);
        // A full overlay as an old version would have written it: every entry present, most of them
        // carrying exactly the shipped value with no local_change at all.
        $this->seedOverlay([
            'unchanged_one' => ['value' => 'A', 'original' => 'A'],
            'unchanged_two' => ['value' => 'B', 'original' => 'B'],
            'changed' => ['value' => 'C, lokal', 'original' => 'C', 'local_change' => '2020-01-01T00:00:00Z'],
        ]);
 
        $this->sync(['unchanged_one' => 'A', 'unchanged_two' => 'B', 'changed' => 'C, lokal'], true);
 
        $this->assertSame(['changed'], $this->overlayIdentifiers());
        $this->assertSame(
            '2020-01-01T00:00:00Z',
            LocalChangeComments::getLocalChange($this->overlayPo()->find(null, 'changed'))
        );
    }

References MigratedLanguageFileSyncTestCase\overlayIdentifiers(), MigratedLanguageFileSyncTestCase\overlayPo(), MigratedLanguageFileSyncTestCase\seedOverlay(), MigratedLanguageFileSyncTestCase\seedShipped(), and MigratedLanguageFileSyncTestCase\sync().

Here is the call graph for this function:

◆ testAnAdminEditNeverMovesTheOriginal()

MigratedLanguageFileSyncDeltaTest::testAnAdminEditNeverMovesTheOriginal ( )

refresh = false (an ordinary admin edit): the baseline "original" must never move - even when the shipped file changed in the meantime.

Definition at line 157 of file MigratedLanguageFileSyncDeltaTest.php.

                                                          : void
    {
        $this->seedShipped(['greeting' => 'Hallo, neu']);
        $this->seedOverlay(['greeting' => ['value' => 'Hallo', 'original' => 'Hallo']]);
 
        $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));
    }

References MigratedLanguageFileSyncTestCase\overlayPo(), MigratedLanguageFileSyncTestCase\seedOverlay(), MigratedLanguageFileSyncTestCase\seedShipped(), and MigratedLanguageFileSyncTestCase\sync().

Here is the call graph for this function:

◆ testAnAdminEditRemovesFuzzyOnlyFromTheValuesItActuallyChanges()

MigratedLanguageFileSyncDeltaTest::testAnAdminEditRemovesFuzzyOnlyFromTheValuesItActuallyChanges ( )

Definition at line 170 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                                   : void
    {
        $this->seedShipped([
            'kept' => ['value' => 'Hello', 'fuzzy' => true],
            'edited' => ['value' => 'Bye', 'fuzzy' => true],
        ]);
        $this->seedOverlay([
            'kept' => ['value' => 'Hello', 'original' => 'Hello', 'fuzzy' => true],
            'edited' => ['value' => 'Bye', 'original' => 'Bye', 'fuzzy' => true],
        ]);
 
        $this->sync(['kept' => 'Hello', 'edited' => 'Tschüss']);
 
        // the kept shipped value (fuzzy in the shipped .po) leaves the overlay, the edited one is no longer fuzzy
        $overlay = $this->overlayPo();
        $this->assertNull($overlay->find(null, 'kept'));
        $this->assertFalse($overlay->find(null, 'edited')->hasFlag('fuzzy'));
    }

References MigratedLanguageFileSyncTestCase\overlayPo(), MigratedLanguageFileSyncTestCase\seedOverlay(), MigratedLanguageFileSyncTestCase\seedShipped(), and MigratedLanguageFileSyncTestCase\sync().

Here is the call graph for this function:

◆ testCreatingTheOverlayGivesAnEntryWithoutShippedCounterpartNoOriginalButALocalChange()

MigratedLanguageFileSyncDeltaTest::testCreatingTheOverlayGivesAnEntryWithoutShippedCounterpartNoOriginalButALocalChange ( )

Definition at line 75 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                                                          : void
    {
        $this->seedShipped(['greeting' => 'Hallo']);
 
        $this->sync(['greeting' => 'Hallo', 'custom' => 'Eigener Wert']);
 
        $custom = $this->overlayPo()->find(null, 'custom');
        $this->assertSame('Eigener Wert', $custom->getTranslation());
        $this->assertNull(LocalChangeComments::getOriginal($custom));
        $this->assertNotNull(LocalChangeComments::getLocalChange($custom));
    }

References MigratedLanguageFileSyncTestCase\overlayPo(), MigratedLanguageFileSyncTestCase\seedShipped(), and MigratedLanguageFileSyncTestCase\sync().

Here is the call graph for this function:

◆ testCreatingTheOverlayKeepsShippedFuzzyOnlyForTheUnchangedShippedValue()

MigratedLanguageFileSyncDeltaTest::testCreatingTheOverlayKeepsShippedFuzzyOnlyForTheUnchangedShippedValue ( )

A shipped "fuzzy" (an unreviewed value, usually the English fallback) must survive the very first sync as long as the value is still the shipped one - and must not be copied onto a value that differs from it.

Definition at line 92 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                                            : void
    {
        $this->seedShipped([
            'unchanged' => ['value' => 'Hello', 'fuzzy' => true],
            'changed' => ['value' => 'Bye', 'fuzzy' => true],
            'reviewed' => ['value' => 'Hallo'],
        ]);
 
        $this->sync(['unchanged' => 'Hello', 'changed' => 'Tschüss', 'reviewed' => 'Hallo']);
 
        // the shipped values (and their fuzzy flag) stay in the shipped .po, only the changed value enters the overlay
        // - never fuzzy
        $overlay = $this->overlayPo();
        $this->assertNull($overlay->find(null, 'unchanged'));
        $this->assertFalse($overlay->find(null, 'changed')->hasFlag('fuzzy'));
        $this->assertNull($overlay->find(null, 'reviewed'));
    }

References MigratedLanguageFileSyncTestCase\overlayPo(), MigratedLanguageFileSyncTestCase\seedShipped(), and MigratedLanguageFileSyncTestCase\sync().

Here is the call graph for this function:

◆ testCreatingTheOverlayWithADeviatingValueRecordsShippedOriginalAndALocalChange()

MigratedLanguageFileSyncDeltaTest::testCreatingTheOverlayWithADeviatingValueRecordsShippedOriginalAndALocalChange ( )

Definition at line 60 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                                                    : void
    {
        $this->seedShipped(['greeting' => 'Hallo']);
 
        $this->sync(['greeting' => 'Servus']);
 
        $greeting = $this->overlayPo()->find(null, 'greeting');
        $this->assertSame('Servus', $greeting->getTranslation());
        $this->assertSame('Hallo', LocalChangeComments::getOriginal($greeting));
        $this->assertMatchesRegularExpression(
            '/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/',
            (string) LocalChangeComments::getLocalChange($greeting)
        );
    }

References MigratedLanguageFileSyncTestCase\overlayPo(), MigratedLanguageFileSyncTestCase\seedShipped(), and MigratedLanguageFileSyncTestCase\sync().

Here is the call graph for this function:

◆ testEntriesAreWrittenSortedByIdentifier()

MigratedLanguageFileSyncDeltaTest::testEntriesAreWrittenSortedByIdentifier ( )

Sorted byte-wise by identifier, independent of the order of $entries - keeps the file diff-stable.

SORT_STRING: upper case before lower case, "10" before "9".

Definition at line 434 of file MigratedLanguageFileSyncDeltaTest.php.

                                                             : void
    {
        $this->seedShipped(['b' => 'B']);
 
        $this->sync(['b' => 'B', 'a' => 'A', 'C' => 'C', '9' => 'neun', '10' => 'zehn']);
 
        // "b" carries the shipped value and is not written
        $this->assertSame(['10', '9', 'C', 'a'], $this->overlayIdentifiers());
    }

◆ testEntriesOfAnotherContextInTheOldOverlayAreNotCarriedOver()

MigratedLanguageFileSyncDeltaTest::testEntriesOfAnotherContextInTheOldOverlayAreNotCarriedOver ( )

Entries of a different context (another module) are never taken over into this module's overlay: the overlay holds exactly $entries.

Definition at line 416 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                                 : void
    {
        $this->seedShipped(['greeting' => 'Hallo']);
        $this->seedOverlay([
            'greeting' => ['value' => 'Hallo', 'original' => 'Hallo'],
            'foreign' => ['value' => 'Fremd', 'context' => 'other_module'],
        ]);
 
        // a local change keeps an overlay to look into (delta)
        $this->sync(['greeting' => 'Servus']);
 
        $this->assertNull($this->overlayPo()->find('other_module', 'foreign'));
    }

◆ testRefreshKeepsTheOriginalOfAnEntryTheShippedPoNoLongerContains()

MigratedLanguageFileSyncDeltaTest::testRefreshKeepsTheOriginalOfAnEntryTheShippedPoNoLongerContains ( )

An entry the shipped .po no longer contains (kept by the caller as a real local change, see LanguageInstallationManager::resolveMigratedModule()) keeps its last "original" and its local_change date - so a later update can still tell it from an unchanged entry.

Definition at line 322 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                                      : void
    {
        $this->seedShipped(['greeting' => 'Hallo']);
        $this->seedOverlay([
            'greeting' => ['value' => 'Hallo', 'original' => 'Hallo'],
            'dropped' => ['value' => 'Neu', 'original' => 'Alt', 'local_change' => '2020-01-01T00:00:00Z'],
        ]);
 
        $this->sync(['greeting' => 'Hallo', 'dropped' => 'Neu'], true);
 
        $dropped = $this->overlayPo()->find(null, 'dropped');
        $this->assertSame('Alt', LocalChangeComments::getOriginal($dropped));
        $this->assertSame('2020-01-01T00:00:00Z', LocalChangeComments::getLocalChange($dropped));
    }

References MigratedLanguageFileSyncTestCase\overlayPo(), MigratedLanguageFileSyncTestCase\seedOverlay(), MigratedLanguageFileSyncTestCase\seedShipped(), and MigratedLanguageFileSyncTestCase\sync().

Here is the call graph for this function:

◆ testRefreshMovesTheOriginalButKeepsALocalCustomizationFlagged()

MigratedLanguageFileSyncDeltaTest::testRefreshMovesTheOriginalButKeepsALocalCustomizationFlagged ( )

Definition at line 302 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                                   : void
    {
        $this->seedShipped(['greeting' => 'Hallo, überarbeitet']);
        $this->seedOverlay([
            'greeting' => ['value' => 'Servus', 'original' => 'Hallo', 'local_change' => '2020-01-01T00:00:00Z'],
        ]);
 
        $this->sync(['greeting' => 'Servus'], true);
 
        $greeting = $this->overlayPo()->find(null, 'greeting');
        $this->assertSame('Servus', $greeting->getTranslation());
        $this->assertSame('Hallo, überarbeitet', LocalChangeComments::getOriginal($greeting));
        $this->assertSame('2020-01-01T00:00:00Z', LocalChangeComments::getLocalChange($greeting));
    }

References MigratedLanguageFileSyncTestCase\overlayPo(), MigratedLanguageFileSyncTestCase\seedOverlay(), MigratedLanguageFileSyncTestCase\seedShipped(), and MigratedLanguageFileSyncTestCase\sync().

Here is the call graph for this function:

◆ testRefreshMovesTheOriginalToTheNewShippedValueAndClearsTheLocalChangeOfAnUnmodifiedEntry()

MigratedLanguageFileSyncDeltaTest::testRefreshMovesTheOriginalToTheNewShippedValueAndClearsTheLocalChangeOfAnUnmodifiedEntry ( )

Definition at line 287 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                                                               : void
    {
        $this->seedShipped(['greeting' => 'Hallo, überarbeitet']);
        $this->seedOverlay(['greeting' => ['value' => 'Hallo', 'original' => 'Hallo']]);
 
        $this->sync(['greeting' => 'Hallo, überarbeitet'], true);
 
        // the new shipped value is served from the shipped .po, the outdated overlay entry is removed
        $this->assertFileDoesNotExist($this->overlayBase() . '.po');
        $this->assertSame(
            ['value' => 'Hallo, überarbeitet', 'local_change' => false, 'local_change_date' => null, 'original' => 'Hallo, überarbeitet'],
            MigratedLanguageFileSync::loadModuleTranslations($this->manager, 'de', self::MODULE, $this->client_data_dir)['greeting']
        );
    }

References MigratedLanguageFileSyncTestCase\overlayBase(), MigratedLanguageFileSyncTestCase\seedOverlay(), MigratedLanguageFileSyncTestCase\seedShipped(), and MigratedLanguageFileSyncTestCase\sync().

Here is the call graph for this function:

◆ testRefreshRecomputesFuzzyFromTheShippedEntry()

MigratedLanguageFileSyncDeltaTest::testRefreshRecomputesFuzzyFromTheShippedEntry	(	array	$shipped,
		array	$overlay,
		string	$value,
		?bool	$expected_fuzzy
	)

On refresh fuzzy is recomputed from the shipped file: set exactly when the value is the shipped value and the shipped entry is fuzzy.

Parameters

array<string,mixed>	$shipped
array<string,mixed>	$overlay

Definition at line 345 of file MigratedLanguageFileSyncDeltaTest.php.

     : void {
        $this->seedShipped(['greeting' => $shipped]);
        $this->seedOverlay(['greeting' => $overlay]);
 
        $this->sync(['greeting' => $value], true);
 
        // `null`: the value is the shipped one, so the entry (and its fuzzy flag) lives in the shipped .po only and the
        // overlay is removed
        if ($expected_fuzzy === null) {
            $this->assertFileDoesNotExist($this->overlayBase() . '.po');
            return;
        }
        $this->assertSame($expected_fuzzy, $this->overlayPo()->find(null, 'greeting')->hasFlag('fuzzy'));
    }

◆ testReplaceSemanticsRemoveEveryEntryThatIsNotPassed()

MigratedLanguageFileSyncDeltaTest::testReplaceSemanticsRemoveEveryEntryThatIsNotPassed ( )

Definition at line 383 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                         : void
    {
        $this->seedShipped(['greeting' => 'Hallo', 'farewell' => 'Tschüss']);
        // local changes, since shipped values are never in the overlay
        $this->seedOverlay([
            'greeting' => ['value' => 'Servus', 'original' => 'Hallo', 'local_change' => '2020-01-01T00:00:00Z'],
            'farewell' => ['value' => 'Pfiat di', 'original' => 'Tschüss', 'local_change' => '2020-01-01T00:00:00Z'],
        ]);
 
        $this->sync(['greeting' => 'Servus']);
 
        $this->assertSame(['greeting'], $this->overlayIdentifiers());
        $this->assertSame(['greeting' => 'Servus'], MigratedPoFixture::readMo(MigratedPoFixture::overlayMo($this->overlayBase())));
    }

References MigratedPoFixture\overlayMo(), and MigratedPoFixture\readMo().

Here is the call graph for this function:

◆ testSyncingNoEntriesRemovesTheOverlayButKeepsTheShippedFile()

MigratedLanguageFileSyncDeltaTest::testSyncingNoEntriesRemovesTheOverlayButKeepsTheShippedFile ( )

An empty delta removes the overlay files - the shipped file and the lock file are kept.

Definition at line 399 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                                 : void
    {
        $this->seedShipped(['greeting' => 'Hallo']);
        $this->seedOverlay(['greeting' => ['value' => 'Servus', 'original' => 'Hallo', 'local_change' => '2020-01-01T00:00:00Z']]);
 
        $this->sync([]);
 
        $this->assertFileDoesNotExist($this->overlayBase() . '.po');
        $this->assertFileDoesNotExist(MigratedPoFixture::overlayMo($this->overlayBase()));
        $this->assertFileExists(MigratedPoFixture::overlayLock($this->overlayBase()), 'the lock file is only removed on uninstall');
        $this->assertNotNull(MigratedPoFixture::readPo($this->shippedPo())->find(self::MODULE, 'greeting'));
    }

References MigratedPoFixture\overlayLock(), MigratedPoFixture\overlayMo(), and MigratedPoFixture\readPo().

Here is the call graph for this function:

◆ testSyncingOnlyShippedValuesWritesNoOverlay()

MigratedLanguageFileSyncDeltaTest::testSyncingOnlyShippedValuesWritesNoOverlay ( bool $refresh )

A module whose values are all shipped ones needs no overlay: neither file, lock nor directory is created, by an admin edit or a reconciling write.

Definition at line 41 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                              : void
    {
        $this->seedShipped(['greeting' => 'Hallo', 'farewell' => 'Tschüss']);
        $shipped_before = file_get_contents($this->shippedPo());
 
        $this->sync(['greeting' => 'Hallo', 'farewell' => 'Tschüss'], $refresh);
 
        $this->assertFileDoesNotExist($this->overlayBase() . '.po');
        $this->assertFileDoesNotExist(MigratedPoFixture::overlayMo($this->overlayBase()));
        $this->assertFileDoesNotExist(MigratedPoFixture::overlayLock($this->overlayBase()));
        $this->assertDirectoryDoesNotExist(dirname($this->overlayBase()));
        $this->assertSame($shipped_before, file_get_contents($this->shippedPo()), 'the shipped .po is never written');
    }

References MigratedLanguageFileSyncTestCase\overlayBase(), MigratedPoFixture\overlayLock(), MigratedPoFixture\overlayMo(), MigratedLanguageFileSyncTestCase\seedShipped(), MigratedLanguageFileSyncTestCase\shippedPo(), and MigratedLanguageFileSyncTestCase\sync().

Here is the call graph for this function:

◆ testTheDeltaIsComparedAgainstTheRawShippedValueNotTheMarkupCleanedOne()

MigratedLanguageFileSyncDeltaTest::testTheDeltaIsComparedAgainstTheRawShippedValueNotTheMarkupCleanedOne ( )

The delta is compared against the RAW shipped .po value (TranslationCatalog::fromPoFile()), not the markup- cleaned value the build serves: a value with markup TranslationMarkupPolicy disallows is still the shipped value, so writing it back creates no delta.

Definition at line 115 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                                           : void
    {
        $this->seedShipped(['greeting' => '<script>alert(1)</script>Hallo']);
 
        $this->sync(['greeting' => '<script>alert(1)</script>Hallo']);
 
        $this->assertFileDoesNotExist($this->overlayBase() . '.po');
    }

References MigratedLanguageFileSyncTestCase\overlayBase(), MigratedLanguageFileSyncTestCase\seedShipped(), and MigratedLanguageFileSyncTestCase\sync().

Here is the call graph for this function:

◆ testTheLocalChangeTimestampOfAnUntouchedEntrySurvivesAnUnrelatedWrite()

MigratedLanguageFileSyncDeltaTest::testTheLocalChangeTimestampOfAnUntouchedEntrySurvivesAnUnrelatedWrite ( )

A full-replace write re-sends every value; an entry whose value did not change must keep its existing local_change timestamp (seeded with a fixed, old value - no sleep()/clock needed).

Definition at line 213 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                                           : void
    {
        $this->seedShipped(['greeting' => 'Hallo', 'farewell' => 'Tschüss']);
        $this->seedOverlay([
            'greeting' => ['value' => 'Servus', 'original' => 'Hallo', 'local_change' => '2020-01-01T00:00:00Z'],
            'farewell' => ['value' => 'Tschüss', 'original' => 'Tschüss'],
        ]);
 
        $this->sync(['greeting' => 'Servus', 'farewell' => 'Pfiat di']);
 
        $overlay = $this->overlayPo();
        $this->assertSame('2020-01-01T00:00:00Z', LocalChangeComments::getLocalChange($overlay->find(null, 'greeting')));
        $farewell_change = LocalChangeComments::getLocalChange($overlay->find(null, 'farewell'));
        $this->assertNotNull($farewell_change);
        $this->assertNotSame('2020-01-01T00:00:00Z', $farewell_change);
    }

References MigratedLanguageFileSyncTestCase\overlayPo(), MigratedLanguageFileSyncTestCase\seedOverlay(), MigratedLanguageFileSyncTestCase\seedShipped(), and MigratedLanguageFileSyncTestCase\sync().

Here is the call graph for this function:

◆ testTheOverlayTakesTheExtractedCommentsOfTheShippedEntry()

MigratedLanguageFileSyncDeltaTest::testTheOverlayTakesTheExtractedCommentsOfTheShippedEntry ( )

Extracted comments ("#. ...", context for translators) are part of the shipped file and are carried into the overlay on creation/refresh.

Definition at line 128 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                              : void
    {
        $catalog = MigratedPoFixture::catalog(self::MODULE, ['greeting' => 'Hallo']);
        $catalog->find(self::MODULE, 'greeting')->addExtractedComment('shown on the login page');
        MigratedPoFixture::writePo($this->shippedPo(), $catalog);
 
        $this->sync(['greeting' => 'Servus']);
 
        $this->assertSame(['shown on the login page'], $this->overlayPo()->find(null, 'greeting')->getExtractedComments());
    }

References MigratedPoFixture\catalog(), MigratedLanguageFileSyncTestCase\overlayPo(), MigratedLanguageFileSyncTestCase\shippedPo(), MigratedLanguageFileSyncTestCase\sync(), and MigratedPoFixture\writePo().

Here is the call graph for this function:

◆ testTheOverlayTakesTheHeadersOfTheShippedPo()

MigratedLanguageFileSyncDeltaTest::testTheOverlayTakesTheHeadersOfTheShippedPo ( )

Definition at line 139 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                 : void
    {
        $catalog = MigratedPoFixture::catalog(self::MODULE, ['greeting' => 'Hallo']);
        $catalog->setHeader('Language', 'de');
        $catalog->setHeader('Plural-Forms', 'nplurals=2; plural=(n != 1);');
        MigratedPoFixture::writePo($this->shippedPo(), $catalog);
 
        // a local change - with only shipped values there is no overlay (delta)
        $this->sync(['greeting' => 'Servus']);
 
        $this->assertSame('de', $this->overlayPo()->getHeader('Language'));
        $this->assertSame('nplurals=2; plural=(n != 1);', $this->overlayPo()->getHeader('Plural-Forms'));
    }

References MigratedPoFixture\catalog(), MigratedLanguageFileSyncTestCase\overlayPo(), MigratedLanguageFileSyncTestCase\shippedPo(), MigratedLanguageFileSyncTestCase\sync(), and MigratedPoFixture\writePo().

Here is the call graph for this function:

◆ testWritingTheOriginalValueBackClearsTheLocalChange()

MigratedLanguageFileSyncDeltaTest::testWritingTheOriginalValueBackClearsTheLocalChange ( )

Definition at line 189 of file MigratedLanguageFileSyncDeltaTest.php.

                                                                         : void
    {
        $this->seedShipped(['greeting' => 'Hallo']);
        $this->seedOverlay([
            'greeting' => ['value' => 'Servus', 'original' => 'Hallo', 'local_change' => '2020-01-01T00:00:00Z'],
        ]);
 
        $this->sync(['greeting' => 'Hallo']);
 
        // the shipped value again is no local change: the entry, and with it the now empty overlay, is removed
        $this->assertFileDoesNotExist($this->overlayBase() . '.po');
        $this->assertFileDoesNotExist(MigratedPoFixture::overlayMo($this->overlayBase()));
        $this->assertFalse(MigratedLanguageFileSync::loadModuleTranslations(
            $this->manager,
            'de',
            self::MODULE,
            $this->client_data_dir
        )['greeting']['local_change']);
    }

References MigratedLanguageFileSyncTestCase\overlayBase(), MigratedPoFixture\overlayMo(), MigratedLanguageFileSyncTestCase\seedOverlay(), MigratedLanguageFileSyncTestCase\seedShipped(), and MigratedLanguageFileSyncTestCase\sync().

Here is the call graph for this function:

The documentation for this class was generated from the following file:

components/ILIAS/Language/tests/ComponentTranslation/MigratedLanguageFileSyncDeltaTest.php

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ refreshFlags()

◆ refreshFuzzyCases()

◆ testALegacyEntryWithTheModuleAsMsgctxtIsMigratedToNoContextPreservingItsBookkeeping()

◆ testALegacyFullOverlayShrinksToTheDeltaOnTheNextReconcilingWrite()

◆ testAnAdminEditNeverMovesTheOriginal()

◆ testAnAdminEditRemovesFuzzyOnlyFromTheValuesItActuallyChanges()

◆ testCreatingTheOverlayGivesAnEntryWithoutShippedCounterpartNoOriginalButALocalChange()

◆ testCreatingTheOverlayKeepsShippedFuzzyOnlyForTheUnchangedShippedValue()

◆ testCreatingTheOverlayWithADeviatingValueRecordsShippedOriginalAndALocalChange()

◆ testEntriesAreWrittenSortedByIdentifier()

◆ testEntriesOfAnotherContextInTheOldOverlayAreNotCarriedOver()

◆ testRefreshKeepsTheOriginalOfAnEntryTheShippedPoNoLongerContains()

◆ testRefreshMovesTheOriginalButKeepsALocalCustomizationFlagged()

◆ testRefreshMovesTheOriginalToTheNewShippedValueAndClearsTheLocalChangeOfAnUnmodifiedEntry()

◆ testRefreshRecomputesFuzzyFromTheShippedEntry()

◆ testReplaceSemanticsRemoveEveryEntryThatIsNotPassed()

◆ testSyncingNoEntriesRemovesTheOverlayButKeepsTheShippedFile()

◆ testSyncingOnlyShippedValuesWritesNoOverlay()

◆ testTheDeltaIsComparedAgainstTheRawShippedValueNotTheMarkupCleanedOne()

◆ testTheLocalChangeTimestampOfAnUntouchedEntrySurvivesAnUnrelatedWrite()

◆ testTheOverlayTakesTheExtractedCommentsOfTheShippedEntry()

◆ testTheOverlayTakesTheHeadersOfTheShippedPo()

◆ testWritingTheOriginalValueBackClearsTheLocalChange()