GroupSynchronizationCacheTest.php
No OneTemporary
Actions

Size

11 KB

Referenced Files

None

Subscribers

None

GroupSynchronizationCacheTest.php
View Options

	<?php

	namespace MediaWiki\Extension\Translate\Synchronization;

	use InvalidArgumentException;
	use LogicException;
	use MediaWiki\Extension\Translate\Cache\PersistentDatabaseCache;
	use MediaWikiIntegrationTestCase;

	/**
	* @group Database
	* @covers \MediaWiki\Extension\Translate\Synchronization\GroupSynchronizationCache
	* @covers \MediaWiki\Extension\Translate\Synchronization\GroupSynchronizationResponse
	*/
	class GroupSynchronizationCacheTest extends MediaWikiIntegrationTestCase {
	/** @var GroupSynchronizationCache */
	private $groupSyncCache;

	protected function setUp(): void {
	parent::setUp();
	$this->groupSyncCache = $this->getGroupSynchronizationCache();
	}

	public function testIsGroupBeingProcessed() {
	$groupId = 'hello';
	$this->groupSyncCache->markGroupForSync( $groupId );

	$this->assertTrue( $this->groupSyncCache->isGroupBeingProcessed( $groupId ) );

	$this->groupSyncCache->endSync( $groupId );

	$this->assertFalse( $this->groupSyncCache->isGroupBeingProcessed( $groupId ) );
	}

	public function testGetGroupMessages() {
	$groupId = 'hello';
	$title = 'Title';

	$this->groupSyncCache->markGroupForSync( $groupId );
	$messageParam = $this->getMessageParam( $groupId, $title );
	$this->groupSyncCache->addMessages( $groupId, $messageParam );

	$this->assertEquals(
	[ $title => $messageParam ],
	$this->groupSyncCache->getGroupMessages( $groupId )
	);

	$this->groupSyncCache->removeMessages( $groupId, $title );

	$this->assertSame( [], $this->groupSyncCache->getGroupMessages( $groupId ) );
	}

	public function testMultiGetGroupMessages() {
	$groupId = 'hello';

	$addedMessages = [
	'Title' => $this->getMessageParam( $groupId, 'Title' ),
	'Title_ABC' => $this->getMessageParam( $groupId, 'Title_ABC' )
	];

	$this->groupSyncCache->addMessages( $groupId, ...array_values( $addedMessages ) );

	$messages = $this->groupSyncCache->getGroupMessages( $groupId );
	$this->assertEquals( $addedMessages, $messages );
	}

	public function testIsMessageBeingProcessed() {
	$groupId = 'hello';
	$title = 'Title';

	$this->groupSyncCache->addMessages(
	$groupId, $this->getMessageParam( $groupId, $title )
	);

	$this->assertTrue( $this->groupSyncCache->isMessageBeingProcessed( $groupId, $title ) );

	$this->groupSyncCache->removeMessages( $groupId, $title );

	$this->assertFalse( $this->groupSyncCache->isMessageBeingProcessed( $groupId, $title ) );
	}

	public function testGetGroupsInSync() {
	$groupId = 'hello';

	$this->groupSyncCache->markGroupForSync( $groupId );
	$this->assertSame( [ $groupId ], $this->groupSyncCache->getGroupsInSync() );

	$this->groupSyncCache->endSync( $groupId );
	$this->assertSame( [], $this->groupSyncCache->getGroupsInSync() );
	}

	public function testEndSync() {
	$groupId = 'group-id';
	$title = 'hello';

	$this->startGroupSync( $groupId, $title );

	$this->expectExceptionMessageMatches( '/cannot end synchronization/i' );
	$this->expectException( InvalidArgumentException::class );

	$this->groupSyncCache->endSync( $groupId );

	$messages = $this->groupSyncCache->getGroupMessages( $groupId );
	$this->assertNotEmpty( $messages, 'endSync should not remove group messages' );
	$this->assertIsInt(
	$this->groupSyncCache->getSyncEndTime( $groupId ),
	'endSync should not remove the group key'
	);
	}

	public function testForceEndSync() {
	$groupId = 'group-id';
	$title = 'hello';

	$this->startGroupSync( $groupId, $title );

	$this->groupSyncCache->forceEndSync( $groupId );

	$messages = $this->groupSyncCache->getGroupMessages( $groupId );
	$this->assertSame( [], $messages, 'forceEndSync should remove group messages' );
	$this->assertNull(
	$this->groupSyncCache->getSyncEndTime( $groupId ),
	'forceEndSync should remove the group key'
	);
	}

	/** @dataProvider provideGetSynchronizationStatus */
	public function testGetSynchronizationStatus(
	?int $syncCacheTimeout,
	string $groupId,
	array $titlesToAdd,
	array $titlesToRemove,
	bool $hasTimedOut = false
	) {
	$syncCache = $this->getGroupSynchronizationCache( $syncCacheTimeout );
	$syncCache->markGroupForSync( $groupId );

	$this->assertTrue( $syncCache->isGroupBeingProcessed( $groupId ) );

	$addedMessages = [];
	foreach ( $titlesToAdd as $title ) {
	$messageParam = $this->getMessageParam( $groupId, $title );
	$syncCache->addMessages( $groupId, $messageParam );
	$addedMessages[$title] = $messageParam;
	}

	$this->assertEqualsCanonicalizing( $addedMessages, $syncCache->getGroupMessages( $groupId ) );

	$syncCache->removeMessages( $groupId, ...$titlesToRemove );

	$groupSyncResponse = $syncCache->getSynchronizationStatus( $groupId );

	$diffTitles = array_values( array_diff( $titlesToAdd, $titlesToRemove ) );
	$diffMessages = [];
	foreach ( $diffTitles as $title ) {
	$diffMessages[$title] = $addedMessages[$title];
	}

	$this->assertEquals( $diffMessages, $syncCache->getGroupMessages( $groupId ) );

	if ( $diffMessages === [] ) {
	// getSynchronizationStatus does not perform any updates
	$this->assertContains( $groupId, $this->groupSyncCache->getGroupsInSync() );
	}

	$this->assertSame( $diffMessages === [], $groupSyncResponse->isDone() );
	$this->assertSame( $hasTimedOut, $groupSyncResponse->hasTimedOut() );
	$this->assertEquals( $diffMessages, $groupSyncResponse->getRemainingMessages() );
	$this->assertSame( $groupId, $groupSyncResponse->getGroupId() );
	}

	public function testAddGroupErrors() {
	$this->assertSame( [], $this->groupSyncCache->getGroupsWithErrors() );

	$groupId = 'test-group';
	$groupSyncResponse = $this->addTestGroupError( $groupId );
	$this->assertContains( $groupId, $this->groupSyncCache->getGroupsWithErrors() );
	$this->assertEquals( $groupSyncResponse, $this->groupSyncCache->getGroupErrorInfo( $groupId ) );

	$this->groupSyncCache->addGroupErrors( $groupSyncResponse );
	$this->assertContains(
	$groupId,
	$this->groupSyncCache->getGroupsWithErrors(),
	'Multiple additions of group errors don\'t duplicate entries in cache'
	);
	$this->assertEquals(
	$groupSyncResponse,
	$this->groupSyncCache->getGroupErrorInfo( $groupId ),
	'Multiple additions of group errors don\'t duplicate entries in cache'
	);
	}

	public function testMarkGroupAsResolved() {
	$groupId = 'test-group';
	$this->addTestGroupError( $groupId );

	$this->assertContains( $groupId, $this->groupSyncCache->getGroupsWithErrors() );
	$this->groupSyncCache->markGroupAsResolved( $groupId );
	$this->assertNotContains( $groupId, $this->groupSyncCache->getGroupsWithErrors() );
	}

	public function testMarkMessageAsResolved() {
	$groupId = 'test-group';
	$groupSyncResponse = $this->addTestGroupError( $groupId );

	$this->assertContains( $groupId, $this->groupSyncCache->getGroupsWithErrors() );

	$errorMessages = $groupSyncResponse->getRemainingMessages();
	$pageName = $errorMessages[0]->getPageName();
	$this->groupSyncCache->markMessageAsResolved( $groupId, $pageName );

	$fixedGroupSyncResponse = $this->groupSyncCache->syncGroupErrors( $groupId );
	$fixedErrorMessages = $fixedGroupSyncResponse->getRemainingMessages();

	$this->assertCount( count( $errorMessages ) - 1, $fixedErrorMessages );
	}

	public function testAddGroupErrorsEmpty() {
	$groupId = 'test-group';
	$groupHasTimedOut = true;
	$groupSyncResponse = new GroupSynchronizationResponse( $groupId, [], $groupHasTimedOut );

	$this->expectException( LogicException::class );
	$this->groupSyncCache->addGroupErrors( $groupSyncResponse );
	}

	public function testGroupHasErrors() {
	$groupId = 'test-group';
	$this->addTestGroupError( $groupId );
	$this->assertTrue( $this->groupSyncCache->groupHasErrors( $groupId ) );

	$this->groupSyncCache->markGroupAsResolved( $groupId );
	$this->assertFalse( $this->groupSyncCache->groupHasErrors( $groupId ) );
	}

	public function testGroupInReview() {
	$groupId = 'test-group';
	$this->groupSyncCache->markGroupAsInReview( $groupId );
	$this->assertTrue( $this->groupSyncCache->isGroupInReview( $groupId ) );

	$this->groupSyncCache->markGroupAsInReview( $groupId );
	$this->assertTrue( $this->groupSyncCache->isGroupInReview( $groupId ) );
	}

	/** @dataProvider provideExtendGroupExpiryTime */
	public function testExtendGroupExpiryTime( int $initialExpiryTime, string $expectedCondition ) {
	$groupId = 'test-group-id';
	$this->groupSyncCache = $this->getGroupSynchronizationCache( $initialExpiryTime );

	$this->startGroupSync( $groupId, 'hello' );

	$initialExpiryTime = $this->groupSyncCache->getGroupExpiryTime( $groupId );

	$this->groupSyncCache->extendGroupExpiryTime( $groupId );

	$extendedExpiryTime = $this->groupSyncCache->getGroupExpiryTime( $groupId );

	$this->$expectedCondition( $initialExpiryTime, $extendedExpiryTime );
	}

	public function testExtendInvalidGroupExpiryTime() {
	$this->expectException( LogicException::class );
	$this->expectExceptionMessageMatches( '/group that is not being processed/i' );

	$this->groupSyncCache->extendGroupExpiryTime( 'testGroupId' );
	}

	public function testExtendTimedOutGroupExpiryTime() {
	$groupSyncCache = $this->getGroupSynchronizationCache( -1 );
	$this->groupSyncCache = $groupSyncCache;

	$this->expectException( LogicException::class );
	$this->expectExceptionMessageMatches( '/group that has already expired/i' );

	$groupId = 'test-group-id';
	$this->startGroupSync( $groupId, 'hello' );
	$this->groupSyncCache->extendGroupExpiryTime( $groupId );
	}

	public function provideGetSynchronizationStatus() {
	$groupId = 'hello';
	$defaultSyncCacheTimeout = null;
	$noSyncCacheTimeout = -1;

	yield [
	$defaultSyncCacheTimeout,
	$groupId,
	[ 'Title', 'Title1' ],
	[ 'Title' ],
	false
	];

	yield [
	$defaultSyncCacheTimeout,
	$groupId,
	[ 'Hello' ],
	[ 'Hello' ],
	false
	];

	yield [
	$noSyncCacheTimeout,
	$groupId,
	[ 'Hello' ],
	[ 'Hello' ],
	false
	];

	yield [
	$noSyncCacheTimeout,
	$groupId,
	[ 'Hello', 'Title' ],
	[ 'Hello' ],
	true
	];
	}

	public static function provideExtendGroupExpiryTime() {
	yield 'group expiry time is extended when it is about to expire' => [
	10,
	'assertGreaterThan'
	];

	yield 'group expiry time is not extended when it is not going to expire' => [
	5000,
	'assertEquals'
	];
	}

	private function getMessageParam( string $groupId, string $title ): MessageUpdateParameter {
	return new MessageUpdateParameter( [
	'fuzzy' => true,
	'content' => 'Hello',
	'title' => $title,
	'groupId' => $groupId
	] );
	}

	private function getGroupSynchronizationCache( ?int $timeout = null ): GroupSynchronizationCache {
	$mwServices = $this->getServiceContainer();
	$connectionProvider = $mwServices->getConnectionProvider();
	$jsonCodec = $mwServices->getJsonCodec();
	$persistentCache = new PersistentDatabaseCache( $connectionProvider, $jsonCodec );
	$persistentCache->clear();

	if ( $timeout ) {
	return new GroupSynchronizationCache( $persistentCache, $timeout );
	} else {
	return new GroupSynchronizationCache( $persistentCache );
	}
	}

	private function startGroupSync( string $groupId, string $title ): void {
	$this->groupSyncCache->markGroupForSync( $groupId );
	$this->groupSyncCache->addMessages( $groupId, $this->getMessageParam( $groupId, $title ) );
	}

	private function addTestGroupError( string $groupId ): GroupSynchronizationResponse {
	$groupHasTimedOut = true;
	$groupSyncResponse = new GroupSynchronizationResponse(
	$groupId,
	[
	$this->getMessageParam( $groupId, 'title1' ),
	$this->getMessageParam( $groupId, 'title2' ),
	$this->getMessageParam( $groupId, 'title3' )
	],
	$groupHasTimedOut
	);

	$this->groupSyncCache->addGroupErrors( $groupSyncResponse );
	return $groupSyncResponse;
	}
	}

File Metadata

Mime Type: text/x-php
Expires: Sat, Oct 3, 05:39 (2 w, 5 d ago)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: f9/fa/ef29fcbe82cbb726fbbae4a9345c
Default Alt Text: GroupSynchronizationCacheTest.php (11 KB)

GroupSynchronizationCacheTest.phpNo OneTemporaryActions

GroupSynchronizationCacheTest.phpView Options

File Metadata

Event Timeline

GroupSynchronizationCacheTest.php
No OneTemporary
Actions

GroupSynchronizationCacheTest.php
View Options