szurubooru/tests/Services/HistoryServiceTest.php

<?php
namespace Szurubooru\Tests\Services;
use Szurubooru\Entities\Snapshot;
use Szurubooru\Dao\SnapshotDao;
use Szurubooru\Dao\TransactionManager;
use Szurubooru\Services\AuthService;
use Szurubooru\Services\HistoryService;
use Szurubooru\Services\TimeService;
use Szurubooru\Tests\AbstractTestCase;

final class HistoryServiceTest extends AbstractTestCase
{
	private $snapshotDaoMock;
	private $timeServiceMock;
	private $authServiceMock;
	private $transactionManagerMock;

	public static function dataDifferenceProvider()
	{
		yield
		[
			[],
			[],
			['+' => [], '-' => []]
		];

		yield
		[
			['key' => 'unchangedValue'],
			['key' => 'unchangedValue'],
			['+' => [], '-' => []]
		];

		yield
		[
			['key' => 'newValue'],
			[],
			[
				'+' => ['key' => 'newValue'],
				'-' => []
			]
		];

		yield
		[
			[],
			['key' => 'deletedValue'],
			[
				'+' => [],
				'-' => ['key' => 'deletedValue']
			]
		];

		yield
		[
			['key' => 'changedValue'],
			['key' => 'oldValue'],
			[
				'+' => ['key' => 'changedValue'],
				'-' => ['key' => 'oldValue']
			]
		];

		yield
		[
			['key' => []],
			['key' => []],
			[
				'+' => [],
				'-' => []
			]
		];

		yield
		[
			['key' => ['newArrayElement']],
			['key' => []],
			[
				'+' => ['key' => ['newArrayElement']],
				'-' => []
			]
		];

		yield
		[
			['key' => []],
			['key' => ['removedArrayElement']],
			[
				'+' => [],
				'-' => ['key' => ['removedArrayElement']]
			]
		];

		yield
		[
			['key' => ['unchangedArrayElement', 'newArrayElement']],
			['key' => ['unchangedArrayElement', 'oldArrayElement']],
			[
				'+' => ['key' => ['newArrayElement']],
				'-' => ['key' => ['oldArrayElement']]
			]
		];
	}

	public function setUp()
	{
		parent::setUp();
		$this->snapshotDaoMock = $this->mock(SnapshotDao::class);
		$this->transactionManagerMock = $this->mockTransactionManager();
		$this->timeServiceMock = $this->mock(TimeService::class);
		$this->authServiceMock = $this->mock(AuthService::class);
	}

	/**
	 * @dataProvider dataDifferenceProvider
	 */
	public function testDataDifference($newData, $oldData, $expectedResult)
	{
		$historyService = $this->getHistoryService();
		$this->assertEquals($expectedResult, $historyService->getDataDifference($newData, $oldData));
	}

	public static function mergingProvider()
	{
		{
			//basic merging
			$oldSnapshot = new Snapshot(1);
			$oldSnapshot->setTime(date('c', 1));
			$oldSnapshot->setOperation(Snapshot::OPERATION_CREATION);
			$oldSnapshot->setData(['old' => '1']);

			$newSnapshot = new Snapshot(2);
			$newSnapshot->setTime(date('c', 2));
			$newSnapshot->setOperation(Snapshot::OPERATION_CHANGE);
			$newSnapshot->setData(['new' => '2']);

			$expectedSnapshot = new Snapshot(1);
			$expectedSnapshot->setTime(date('c', 3));
			$expectedSnapshot->setOperation(Snapshot::OPERATION_CREATION);
			$expectedSnapshot->setData(['new' => '2']);
			$expectedSnapshot->setDataDifference(['+' => ['new' => '2'], '-' => []]);

			yield [[$oldSnapshot], $newSnapshot, $expectedSnapshot, date('c', 3), [2]];
		}

		{
			//too big time gap for merge
			$oldSnapshot = new Snapshot(1);
			$oldSnapshot->setOperation(Snapshot::OPERATION_CREATION);
			$oldSnapshot->setData(['old' => '1']);

			$newSnapshot = new Snapshot(2);
			$newSnapshot->setOperation(Snapshot::OPERATION_CHANGE);
			$newSnapshot->setData(['new' => '2']);

			$expectedSnapshot = new Snapshot(2);
			$expectedSnapshot->setTime(date('c', 3000));
			$expectedSnapshot->setOperation(Snapshot::OPERATION_CHANGE);
			$expectedSnapshot->setData(['new' => '2']);
			$expectedSnapshot->setDataDifference(['+' => ['new' => '2'], '-' => ['old' => '1']]);

			yield [[$oldSnapshot], $newSnapshot, $expectedSnapshot, date('c', 3000), []];
		}

		{
			//operations done by different user shouldn't be merged
			$oldSnapshot = new Snapshot(1);
			$oldSnapshot->setOperation(Snapshot::OPERATION_CREATION);
			$oldSnapshot->setData(['old' => '1']);
			$oldSnapshot->setUserId(1);

			$newSnapshot = new Snapshot(2);
			$newSnapshot->setOperation(Snapshot::OPERATION_CHANGE);
			$newSnapshot->setData(['new' => '2']);
			$newSnapshot->setUserId(2);

			$expectedSnapshot = new Snapshot(2);
			$expectedSnapshot->setOperation(Snapshot::OPERATION_CHANGE);
			$expectedSnapshot->setData(['new' => '2']);
			$expectedSnapshot->setDataDifference(['+' => ['new' => '2'], '-' => ['old' => '1']]);
			$expectedSnapshot->setUserId(null);

			yield [[$oldSnapshot], $newSnapshot, $expectedSnapshot, null, []];
		}

		{
			//merge that leaves only delete snapshot should be removed altogether
			$oldSnapshot = new Snapshot(1);
			$oldSnapshot->setOperation(Snapshot::OPERATION_CREATION);
			$oldSnapshot->setData(['old' => '1']);

			$newSnapshot = new Snapshot(2);
			$newSnapshot->setOperation(Snapshot::OPERATION_DELETE);
			$newSnapshot->setData(['new' => '2']);

			yield [[$oldSnapshot], $newSnapshot, null, null, [2, 1]];
		}

		{
			//chaining to creation snapshot should preserve operation type
			$oldestSnapshot = new Snapshot(1);
			$oldestSnapshot->setOperation(Snapshot::OPERATION_CREATION);
			$oldestSnapshot->setData(['oldest' => '0']);

			$oldSnapshot = new Snapshot(2);
			$oldSnapshot->setOperation(Snapshot::OPERATION_CHANGE);
			$oldSnapshot->setData(['old' => '1']);

			$newSnapshot = new Snapshot(3);
			$newSnapshot->setOperation(Snapshot::OPERATION_CHANGE);
			$newSnapshot->setData(['oldest' => '0', 'new' => '2']);

			$expectedSnapshot = new Snapshot(1);
			$expectedSnapshot->setOperation(Snapshot::OPERATION_CREATION);
			$expectedSnapshot->setData(['oldest' => '0', 'new' => '2']);
			$expectedSnapshot->setDataDifference(['+' => ['oldest' => '0', 'new' => '2'], '-' => []]);

			yield [[$oldSnapshot, $oldestSnapshot], $newSnapshot, $expectedSnapshot, null, [3, 2]];

			$newSnapshot = clone($newSnapshot);
			$newSnapshot->setId(null);
			yield [[$oldSnapshot, $oldestSnapshot], $newSnapshot, $expectedSnapshot, null, [2]];
		}

		{
			//chaining to edit snapshot should update operation type
			$oldestSnapshot = new Snapshot(1);
			$oldestSnapshot->setOperation(Snapshot::OPERATION_CREATION);
			$oldestSnapshot->setData(['oldest' => '0']);
			$oldestSnapshot->setTime(date('c', 1));

			$oldSnapshot = new Snapshot(2);
			$oldSnapshot->setOperation(Snapshot::OPERATION_CHANGE);
			$oldSnapshot->setData(['old' => '1']);
			$oldSnapshot->setTime(date('c', 400));

			$newSnapshot = new Snapshot(3);
			$newSnapshot->setOperation(Snapshot::OPERATION_DELETE);
			$newSnapshot->setData(['new' => '2']);
			$newSnapshot->setTime(date('c', 401));

			$expectedSnapshot = new Snapshot(2);
			$expectedSnapshot->setOperation(Snapshot::OPERATION_DELETE);
			$expectedSnapshot->setData(['new' => '2']);
			$expectedSnapshot->setDataDifference(['+' => ['new' => '2'], '-' => ['oldest' => '0']]);
			$expectedSnapshot->setTime(date('c', 402));

			yield [[$oldSnapshot, $oldestSnapshot], $newSnapshot, $expectedSnapshot, date('c', 402), [3]];

			$newSnapshot = clone($newSnapshot);
			$newSnapshot->setId(null);
			yield [[$oldSnapshot, $oldestSnapshot], $newSnapshot, $expectedSnapshot, date('c', 402), []];
		}
	}

	/**
	 * @dataProvider mergingProvider
	 */
	public function testMerging($earlierSnapshots, $newSnapshot, $expectedSnapshot, $currentTime, $expectedDeletions = [])
	{
		$this->timeServiceMock->method('getCurrentTime')->willReturn($currentTime);

		$this->snapshotDaoMock
			->expects($this->once())
			->method('findEarlierSnapshots')
			->willReturn($earlierSnapshots);

		$this->snapshotDaoMock
			->expects($this->exactly($expectedSnapshot === null ? 0 : 1))
			->method('save')
			->will($this->returnCallback(function($param) use (&$actualSnapshot)
				{
					$actualSnapshot = $param;
				}));

		$this->snapshotDaoMock
			->expects($this->exactly(count($expectedDeletions)))
			->method('deleteById')
			->withConsecutive(...array_map(function($del) { return [$del]; }, $expectedDeletions));

		$historyService = $this->getHistoryService();
		$historyService->saveSnapshot($newSnapshot);
		$this->assertEntitiesEqual($expectedSnapshot, $actualSnapshot);
	}

	private function getHistoryService()
	{
		return new HistoryService(
			$this->snapshotDaoMock,
			$this->transactionManagerMock,
			$this->timeServiceMock,
			$this->authServiceMock);
	}
}