EntityConverterLatestRevisionTest.php

<?php

namespace Drupal\KernelTests\Core\ParamConverter;

use Drupal\entity_test\Entity\EntityTest;
use Drupal\entity_test\Entity\EntityTestMulRev;
use Drupal\KernelTests\KernelTestBase;
use Drupal\language\Entity\ConfigurableLanguage;
use Drupal\Tests\user\Traits\UserCreationTrait;

/**
 * Tests the entity converter when the "load_latest_revision" flag is set.
 *
 * @group ParamConverter
 * @coversDefaultClass \Drupal\Core\ParamConverter\EntityConverter
 */
class EntityConverterLatestRevisionTest extends KernelTestBase {
  use UserCreationTrait;
  
  /**
   * Modules to install.
   *
   * @var array
   */
  protected static $modules = [
    'entity_test',
    'user',
    'language',
    'system',
  ];
  
  /**
   * The entity converter service.
   *
   * @var \Drupal\Core\ParamConverter\EntityConverter
   */
  protected $converter;
  
  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    parent::setUp();
    $this->setUpCurrentUser();
    $this->installEntitySchema('entity_test_mulrev');
    $this->installEntitySchema('entity_test');
    $this->installConfig([
      'system',
      'language',
    ]);
    $this->converter = $this->container
      ->get('paramconverter.entity');
    ConfigurableLanguage::createFromLangcode('de')->save();
  }
  
  /**
   * Tests with no matching entity.
   */
  public function testNoEntity() {
    $converted = $this->converter
      ->convert(1, [
      'load_latest_revision' => TRUE,
      'type' => 'entity:entity_test_mulrev',
    ], 'foo', []);
    $this->assertEquals(NULL, $converted);
  }
  
  /**
   * Tests with no pending revision.
   */
  public function testEntityNoPendingRevision() {
    $entity = EntityTestMulRev::create();
    $entity->save();
    $converted = $this->converter
      ->convert(1, [
      'load_latest_revision' => TRUE,
      'type' => 'entity:entity_test_mulrev',
    ], 'foo', []);
    $this->assertEquals($entity->getLoadedRevisionId(), $converted->getLoadedRevisionId());
  }
  
  /**
   * Tests with a pending revision.
   */
  public function testEntityWithPendingRevision() {
    $entity = EntityTestMulRev::create();
    $entity->save();
    $entity->isDefaultRevision(FALSE);
    $entity->setNewRevision(TRUE);
    $entity->save();
    $converted = $this->converter
      ->convert(1, [
      'load_latest_revision' => TRUE,
      'type' => 'entity:entity_test_mulrev',
    ], 'foo', []);
    $this->assertEquals($entity->getLoadedRevisionId(), $converted->getLoadedRevisionId());
  }
  
  /**
   * Tests with a translated pending revision.
   */
  public function testWithTranslatedPendingRevision() {
    // Enable translation for test entities.
    $this->container
      ->get('state')
      ->set('entity_test.translation', TRUE);
    $this->container
      ->get('entity_type.bundle.info')
      ->clearCachedBundles();
    // Create a new English entity.
    $entity = EntityTestMulRev::create();
    $entity->save();
    // Create a translated pending revision.
    $entity_type_id = 'entity_test_mulrev';
    /** @var \Drupal\Core\Entity\ContentEntityStorageInterface $storage */
    $storage = $this->container
      ->get('entity_type.manager')
      ->getStorage($entity_type_id);
    /** @var \Drupal\Core\Entity\ContentEntityInterface $translated_entity */
    $translated_entity = $storage->createRevision($entity->addTranslation('de'), FALSE);
    $translated_entity->save();
    // Change the site language so the converters will attempt to load entities
    // with language 'de'.
    $this->config('system.site')
      ->set('default_langcode', 'de')
      ->save();
    // The default loaded language is still 'en'.
    EntityTestMulRev::load($entity->id());
    $this->assertEquals('en', $entity->language()
      ->getId());
    // The converter will load the latest revision in the correct language.
    $converted = $this->converter
      ->convert(1, [
      'load_latest_revision' => TRUE,
      'type' => 'entity:entity_test_mulrev',
    ], 'foo', []);
    $this->assertEquals('de', $converted->language()
      ->getId());
    $this->assertEquals($translated_entity->getLoadedRevisionId(), $converted->getLoadedRevisionId());
    // Revert back to English as default language.
    $this->config('system.site')
      ->set('default_langcode', 'en')
      ->save();
    // The converter will load the latest revision in the correct language.
    $converted = $this->converter
      ->convert(1, [
      'load_latest_revision' => TRUE,
      'type' => 'entity:entity_test_mulrev',
    ], 'foo', []);
    $this->assertEquals('en', $converted->language()
      ->getId());
    $this->assertEquals($entity->getLoadedRevisionId(), $converted->getLoadedRevisionId());
  }
  
  /**
   * Tests that pending revisions are loaded only when needed.
   */
  public function testOptimizedConvert() {
    $entity = EntityTestMulRev::create();
    $entity->save();
    // Populate static cache for the current entity.
    $entity = EntityTestMulRev::load($entity->id());
    // Delete the base table entry for the current entity, however, since the
    // storage will query the revision table to get the latest revision, the
    // logic handling pending revisions will work correctly anyway.
    /** @var \Drupal\Core\Database\Connection $database */
    $database = $this->container
      ->get('database');
    $database->delete('entity_test_mulrev')
      ->condition('id', $entity->id())
      ->execute();
    // If optimization works, converting a default revision should not trigger
    // a storage load, thus making the following assertion pass.
    $converted = $this->converter
      ->convert(1, [
      'load_latest_revision' => TRUE,
      'type' => 'entity:entity_test_mulrev',
    ], 'foo', []);
    $this->assertEquals($entity->getLoadedRevisionId(), $converted->getLoadedRevisionId());
  }
  
  /**
   * Tests the latest revision flag and non-revisionable entities.
   */
  public function testConvertNonRevisionableEntityType() {
    $entity = EntityTest::create();
    $entity->save();
    $converted = $this->converter
      ->convert(1, [
      'load_latest_revision' => TRUE,
      'type' => 'entity:entity_test',
    ], 'foo', []);
    $this->assertEquals($entity->id(), $converted->id());
  }
  
  /**
   * Tests an entity route parameter having 'bundle' definition property.
   *
   * @covers ::convert
   */
  public function testRouteParamWithBundleDefinition() : void {
    $entity1 = EntityTestMulRev::create([
      'name' => $this->randomString(),
      'type' => 'foo',
    ]);
    $entity1->save();
    $entity2 = EntityTestMulRev::create([
      'name' => $this->randomString(),
      'type' => 'bar',
    ]);
    $entity2->save();
    $entity3 = EntityTestMulRev::create([
      'name' => $this->randomString(),
      'type' => 'baz',
    ]);
    $entity3->save();
    $definition = [
      'type' => 'entity:entity_test_mulrev',
      'bundle' => [
        'foo',
        'bar',
      ],
      'load_latest_revision' => TRUE,
    ];
    // An entity whose bundle is in the definition list is converted.
    $converted = $this->converter
      ->convert($entity1->id(), $definition, 'qux', []);
    $this->assertSame($entity1->id(), $converted->id());
    // An entity whose bundle is in the definition list is converted.
    $converted = $this->converter
      ->convert($entity2->id(), $definition, 'qux', []);
    $this->assertSame($entity2->id(), $converted->id());
    // An entity whose bundle is missed from definition is not converted.
    $converted = $this->converter
      ->convert($entity3->id(), $definition, 'qux', []);
    $this->assertNull($converted);
    // A non-existing entity returns NULL.
    $converted = $this->converter
      ->convert('some-non-existing-entity-id', $definition, 'qux', []);
    $this->assertNull($converted);
    $definition = [
      'type' => 'entity:entity_test_mulrev',
    ];
    // Check that all entities are returned when 'bundle' is not defined.
    $converted = $this->converter
      ->convert($entity1->id(), $definition, 'qux', []);
    $this->assertSame($entity1->id(), $converted->id());
    $converted = $this->converter
      ->convert($entity2->id(), $definition, 'qux', []);
    $this->assertSame($entity2->id(), $converted->id());
    $converted = $this->converter
      ->convert($entity3->id(), $definition, 'qux', []);
    $this->assertSame($entity3->id(), $converted->id());
    $converted = $this->converter
      ->convert('some-non-existing-entity-id', $definition, 'qux', []);
    $this->assertNull($converted);
  }

}