RevisionRevertFormTest.php

<?php

declare (strict_types=1);
namespace Drupal\FunctionalTests\Entity;

use Drupal\Component\Render\FormattableMarkup;
use Drupal\Core\Entity\RevisionLogInterface;
use Drupal\entity_test\Entity\EntityTestRev;
use Drupal\entity_test\Entity\EntityTestRevPub;
use Drupal\entity_test_revlog\Entity\EntityTestWithRevisionLog;
use Drupal\Tests\BrowserTestBase;

/**
 * Tests reverting a revision with revision revert form.
 *
 * @group Entity
 * @group #slow
 * @coversDefaultClass \Drupal\Core\Entity\Form\RevisionRevertForm
 */
class RevisionRevertFormTest extends BrowserTestBase {
    
    /**
     * {@inheritdoc}
     */
    protected $defaultTheme = 'stark';
    
    /**
     * {@inheritdoc}
     */
    protected static $modules = [
        'block',
        'entity_test',
        'entity_test_revlog',
        'dblog',
    ];
    
    /**
     * {@inheritdoc}
     */
    protected function setUp() : void {
        parent::setUp();
        $this->drupalPlaceBlock('page_title_block');
    }
    
    /**
     * Test form revision revert.
     */
    public function testFormRevisionRevert() : void {
        foreach (self::providerPageTitle() as $page_title) {
            $this->testPageTitle($page_title[0], $page_title[1]);
        }
        $this->testAccessRevertLatestDefault();
        $this->testAccessRevertLatestForwardRevision();
        $this->testAccessRevertNonLatest();
        $this->testPrepareRevision();
    }
    
    /**
     * Tests title by whether entity supports revision creation dates.
     *
     * @param string $entityTypeId
     *   The entity type to test.
     * @param string $expectedQuestion
     *   The expected question/page title.
     */
    protected function testPageTitle(string $entityTypeId, string $expectedQuestion) : void {
        
        /** @var \Drupal\Core\Entity\RevisionableStorageInterface $storage */
        $storage = \Drupal::entityTypeManager()->getStorage($entityTypeId);
        $entity = $storage->create([
            'type' => $entityTypeId,
            'name' => 'revert',
        ]);
        if ($entity instanceof RevisionLogInterface) {
            $date = new \DateTime('11 January 2009 4:00:00pm');
            $entity->setRevisionCreationTime($date->getTimestamp());
        }
        $entity->setNewRevision();
        $entity->save();
        $revisionId = $entity->getRevisionId();
        // Create a new latest revision.
        if ($entity instanceof RevisionLogInterface) {
            $entity->setRevisionCreationTime($date->modify('+1 hour')
                ->getTimestamp());
        }
        $entity->setNewRevision();
        $entity->save();
        // Reload the entity.
        $revision = $storage->loadRevision($revisionId);
        $this->drupalGet($revision->toUrl('revision-revert-form'));
        $this->assertSession()
            ->pageTextContains($expectedQuestion);
        $this->assertSession()
            ->buttonExists('Revert');
        $this->assertSession()
            ->linkExists('Cancel');
    }
    
    /**
     * Data provider for testPageTitle.
     */
    protected static function providerPageTitle() : array {
        return [
            [
                'entity_test_rev',
                'Are you sure you want to revert the revision?',
            ],
            [
                'entity_test_revlog',
                'Are you sure you want to revert to the revision from Sun, 01/11/2009 - 16:00?',
            ],
        ];
    }
    
    /**
     * Test cannot revert latest default revision.
     *
     * @covers \Drupal\Core\Entity\EntityAccessControlHandler::checkAccess
     */
    protected function testAccessRevertLatestDefault() : void {
        
        /** @var \Drupal\entity_test\Entity\EntityTestRev $entity */
        $entity = EntityTestRev::create();
        $entity->setName('revert');
        $entity->save();
        $entity->setNewRevision();
        $entity->save();
        $this->drupalGet($entity->toUrl('revision-revert-form'));
        $this->assertSession()
            ->statusCodeEquals(403);
        $this->assertFalse($entity->access('revert', $this->rootUser, FALSE));
    }
    
    /**
     * Ensures that forward revisions can be reverted.
     *
     * @covers \Drupal\Core\Entity\EntityAccessControlHandler::checkAccess
     */
    protected function testAccessRevertLatestForwardRevision() : void {
        
        /** @var \Drupal\entity_test\Entity\EntityTestRev $entity */
        $entity = EntityTestRevPub::create();
        $entity->setName('revert');
        $entity->isDefaultRevision(TRUE);
        $entity->setPublished();
        $entity->setNewRevision();
        $entity->save();
        $entity->isDefaultRevision(FALSE);
        $entity->setUnpublished();
        $entity->setNewRevision();
        $entity->save();
        $this->drupalGet($entity->toUrl('revision-revert-form'));
        $this->assertSession()
            ->statusCodeEquals(200);
        $this->assertTrue($entity->access('revert', $this->rootUser, FALSE));
    }
    
    /**
     * Test can revert non-latest revision.
     *
     * @covers \Drupal\Core\Entity\EntityAccessControlHandler::checkAccess
     */
    protected function testAccessRevertNonLatest() : void {
        
        /** @var \Drupal\entity_test\Entity\EntityTestRev $entity */
        $entity = EntityTestRev::create();
        $entity->setName('revert');
        $entity->save();
        $revisionId = $entity->getRevisionId();
        $entity->setNewRevision();
        $entity->save();
        // Reload the entity.
        
        /** @var \Drupal\Core\Entity\RevisionableStorageInterface $storage */
        $storage = \Drupal::entityTypeManager()->getStorage('entity_test_rev');
        $revision = $storage->loadRevision($revisionId);
        $this->drupalGet($revision->toUrl('revision-revert-form'));
        $this->assertSession()
            ->statusCodeEquals(200);
        $this->assertTrue($revision->access('revert', $this->rootUser, FALSE));
    }
    
    /**
     * Tests revision revert, and expected response after revert.
     *
     * @param array $permissions
     *   If not empty, a user will be created and logged in with these
     *   permissions.
     * @param string $entityTypeId
     *   The entity type to test.
     * @param string $entityLabel
     *   The entity label, which corresponds to access grants.
     * @param string $expectedLog
     *   Expected log.
     * @param string $expectedMessage
     *   Expected messenger message.
     * @param string $expectedDestination
     *   Expected destination after deletion.
     *
     * @covers ::submitForm
     * @dataProvider providerSubmitForm
     */
    public function testSubmitForm(array $permissions, string $entityTypeId, string $entityLabel, string $expectedLog, string $expectedMessage, string $expectedDestination) : void {
        if (count($permissions) > 0) {
            $this->drupalLogin($this->createUser($permissions));
        }
        
        /** @var \Drupal\Core\Entity\RevisionableStorageInterface $storage */
        $storage = \Drupal::entityTypeManager()->getStorage($entityTypeId);
        $entity = $storage->create([
            'type' => $entityTypeId,
            'name' => $entityLabel,
        ]);
        if ($entity instanceof RevisionLogInterface) {
            $date = new \DateTime('11 January 2009 4:00:00pm');
            $entity->setRevisionCreationTime($date->getTimestamp());
        }
        $entity->save();
        $revisionId = $entity->getRevisionId();
        if ($entity instanceof RevisionLogInterface) {
            $entity->setRevisionCreationTime($date->modify('+1 hour')
                ->getTimestamp());
        }
        $entity->setNewRevision();
        $entity->save();
        $revision = $storage->loadRevision($revisionId);
        $this->drupalGet($revision->toUrl('revision-revert-form'));
        $count = $this->countRevisions($entityTypeId);
        $this->submitForm([], 'Revert');
        // A new revision was created.
        $this->assertEquals($count + 1, $this->countRevisions($entityTypeId));
        // Destination.
        $this->assertSession()
            ->statusCodeEquals(200);
        $this->assertSession()
            ->addressEquals($expectedDestination);
        // Logger log.
        $logs = $this->getLogs($entity->getEntityType()
            ->getProvider());
        $this->assertEquals([
            0 => $expectedLog,
        ], $logs);
        // Messenger message.
        $this->assertSession()
            ->pageTextContains($expectedMessage);
    }
    
    /**
     * Data provider for testSubmitForm.
     */
    public static function providerSubmitForm() : array {
        $data = [];
        $data['not supporting revision log, no version history access'] = [
            [
                'view test entity',
            ],
            'entity_test_rev',
            'view, revert',
            'entity_test_rev: reverted <em class="placeholder">view, revert</em> revision <em class="placeholder">1</em>.',
            'Entity Test Bundle view, revert has been reverted.',
            '/entity_test_rev/manage/1',
        ];
        $data['not supporting revision log, version history access'] = [
            [
                'view test entity',
            ],
            'entity_test_rev',
            'view, view all revisions, revert',
            'entity_test_rev: reverted <em class="placeholder">view, view all revisions, revert</em> revision <em class="placeholder">1</em>.',
            'Entity Test Bundle view, view all revisions, revert has been reverted.',
            '/entity_test_rev/1/revisions',
        ];
        $data['supporting revision log, no version history access'] = [
            [],
            'entity_test_revlog',
            'view, revert',
            'entity_test_revlog: reverted <em class="placeholder">view, revert</em> revision <em class="placeholder">1</em>.',
            'Test entity - revisions log view, revert has been reverted to the revision from Sun, 01/11/2009 - 16:00.',
            '/entity_test_revlog/manage/1',
        ];
        $data['supporting revision log, version history access'] = [
            [],
            'entity_test_revlog',
            'view, view all revisions, revert',
            'entity_test_revlog: reverted <em class="placeholder">view, view all revisions, revert</em> revision <em class="placeholder">1</em>.',
            'Test entity - revisions log view, view all revisions, revert has been reverted to the revision from Sun, 01/11/2009 - 16:00.',
            '/entity_test_revlog/1/revisions',
        ];
        return $data;
    }
    
    /**
     * Tests the revert process.
     *
     * @covers ::prepareRevision
     */
    protected function testPrepareRevision() : void {
        $user = $this->createUser();
        $this->drupalLogin($user);
        
        /** @var \Drupal\entity_test_revlog\Entity\EntityTestWithRevisionLog $entity */
        $entity = EntityTestWithRevisionLog::create([
            'type' => 'entity_test_revlog',
            'name' => 'revert',
        ]);
        $date = new \DateTime('11 January 2009 4:00:00pm');
        $entity->setRevisionCreationTime($date->getTimestamp());
        $entity->isDefaultRevision(TRUE);
        $entity->setNewRevision();
        $entity->save();
        $revisionCreationTime = $date->modify('+1 hour')
            ->getTimestamp();
        $entity->setRevisionCreationTime($revisionCreationTime);
        $entity->setRevisionUserId(0);
        $entity->isDefaultRevision(FALSE);
        $entity->setNewRevision();
        $entity->save();
        $targetRevertRevisionId = $entity->getRevisionId();
        // Create a another revision so the previous revision can be reverted to.
        $entity->setRevisionCreationTime($date->modify('+1 hour')
            ->getTimestamp());
        $entity->isDefaultRevision(FALSE);
        $entity->setNewRevision();
        $entity->save();
        $count = $this->countRevisions($entity->getEntityTypeId());
        // Load the revision to be copied.
        
        /** @var \Drupal\Core\Entity\RevisionableStorageInterface $storage */
        $storage = \Drupal::entityTypeManager()->getStorage($entity->getEntityTypeId());
        
        /** @var \Drupal\entity_test_revlog\Entity\EntityTestWithRevisionLog $targetRevision */
        $targetRevision = $storage->loadRevision($targetRevertRevisionId);
        $this->drupalGet($targetRevision->toUrl('revision-revert-form'));
        $this->submitForm([], 'Revert');
        // Load the new latest revision.
        
        /** @var \Drupal\entity_test_revlog\Entity\EntityTestWithRevisionLog $latestRevision */
        $latestRevision = $storage->loadUnchanged($entity->id());
        $this->assertEquals($count + 1, $this->countRevisions($entity->getEntityTypeId()));
        $this->assertEquals('Copy of the revision from <em class="placeholder">Sun, 01/11/2009 - 17:00</em>.', $latestRevision->getRevisionLogMessage());
        $this->assertGreaterThan($revisionCreationTime, $latestRevision->getRevisionCreationTime());
        $this->assertEquals($user->id(), $latestRevision->getRevisionUserId());
        $this->assertTrue($latestRevision->isDefaultRevision());
    }
    
    /**
     * Loads watchdog entries by channel.
     *
     * @param string $channel
     *   The logger channel.
     *
     * @return string[]
     *   Watchdog entries.
     */
    protected function getLogs(string $channel) : array {
        $logs = \Drupal::database()->query("SELECT * FROM {watchdog} WHERE type = :type", [
            ':type' => $channel,
        ])
            ->fetchAll();
        return array_map(function (object $log) {
            return (string) new FormattableMarkup($log->message, unserialize($log->variables));
        }, $logs);
    }
    
    /**
     * Count number of revisions for an entity type.
     *
     * @param string $entityTypeId
     *   The entity type.
     *
     * @return int
     *   Number of revisions for an entity type.
     */
    protected function countRevisions(string $entityTypeId) : int {
        return (int) \Drupal::entityTypeManager()->getStorage($entityTypeId)
            ->getQuery()
            ->accessCheck(FALSE)
            ->allRevisions()
            ->count()
            ->execute();
    }

}