www.aleph1.co.uk Git - yaffs-website/blob - web/core/tests/Drupal/KernelTests/Core/Entity/EntityRevisionTranslationTest.php

   1 <?php
   2
   3 namespace Drupal\KernelTests\Core\Entity;
   4
   5 use Drupal\entity_test\Entity\EntityTestMul;
   6 use Drupal\entity_test\Entity\EntityTestMulRev;
   7 use Drupal\language\Entity\ConfigurableLanguage;
   8
   9 /**
  10  * Tests proper revision propagation of entities.
  11  *
  12  * @group Entity
  13  */
  14 class EntityRevisionTranslationTest extends EntityKernelTestBase {
  15
  16   /**
  17    * {@inheritdoc}
  18    */
  19   public static $modules = ['language'];
  20
  21   /**
  22    * {@inheritdoc}
  23    */
  24   protected function setUp() {
  25     parent::setUp();
  26
  27     // Enable some additional languages.
  28     ConfigurableLanguage::createFromLangcode('de')->save();
  29     ConfigurableLanguage::createFromLangcode('it')->save();
  30
  31     $this->installEntitySchema('entity_test_mul');
  32     $this->installEntitySchema('entity_test_mulrev');
  33   }
  34
  35   /**
  36    * Tests if the translation object has the right revision id after new revision.
  37    */
  38   public function testNewRevisionAfterTranslation() {
  39     $user = $this->createUser();
  40
  41     // Create a test entity.
  42     $entity = EntityTestMulRev::create([
  43       'name' => $this->randomString(),
  44       'user_id' => $user->id(),
  45       'language' => 'en',
  46     ]);
  47     $entity->save();
  48     $old_rev_id = $entity->getRevisionId();
  49
  50     $translation = $entity->addTranslation('de');
  51     $translation->setNewRevision();
  52     $translation->save();
  53
  54     $this->assertTrue($translation->getRevisionId() > $old_rev_id, 'The saved translation in new revision has a newer revision id.');
  55     $this->assertTrue($this->reloadEntity($entity)->getRevisionId() > $old_rev_id, 'The entity from the storage has a newer revision id.');
  56   }
  57
  58   /**
  59    * Tests if the translation object has the right revision id after new revision.
  60    */
  61   public function testRevertRevisionAfterTranslation() {
  62     $user = $this->createUser();
  63     $storage = $this->entityManager->getStorage('entity_test_mulrev');
  64
  65     // Create a test entity.
  66     $entity = EntityTestMulRev::create([
  67       'name' => $this->randomString(),
  68       'user_id' => $user->id(),
  69       'language' => 'en',
  70     ]);
  71     $entity->save();
  72     $old_rev_id = $entity->getRevisionId();
  73
  74     $translation = $entity->addTranslation('de');
  75     $translation->setNewRevision();
  76     $translation->save();
  77
  78     $entity = $this->reloadEntity($entity);
  79
  80     $this->assertTrue($entity->hasTranslation('de'));
  81
  82     $entity = $storage->loadRevision($old_rev_id);
  83
  84     $entity->setNewRevision();
  85     $entity->isDefaultRevision(TRUE);
  86     $entity->save();
  87
  88     $entity = $this->reloadEntity($entity);
  89
  90     $this->assertFalse($entity->hasTranslation('de'));
  91   }
  92
  93   /**
  94    * Tests the translation values when saving a pending revision.
  95    */
  96   public function testTranslationValuesWhenSavingPendingRevisions() {
  97     $user = $this->createUser();
  98     $storage = $this->entityManager->getStorage('entity_test_mulrev');
  99
 100     // Create a test entity and a translation for it.
 101     $entity = EntityTestMulRev::create([
 102       'name' => 'default revision - en',
 103       'user_id' => $user->id(),
 104       'language' => 'en',
 105     ]);
 106     $entity->addTranslation('de', ['name' => 'default revision - de']);
 107     $entity->save();
 108
 109     // Create a pending revision for the entity and change a field value for
 110     // both languages.
 111     $pending_revision = $this->reloadEntity($entity);
 112
 113     $pending_revision->setNewRevision();
 114     $pending_revision->isDefaultRevision(FALSE);
 115
 116     $pending_revision->name = 'pending revision - en';
 117     $pending_revision->save();
 118
 119     $pending_revision_translation = $pending_revision->getTranslation('de');
 120     $pending_revision_translation->name = 'pending revision - de';
 121     $pending_revision_translation->save();
 122
 123     $pending_revision_id = $pending_revision->getRevisionId();
 124     $pending_revision = $storage->loadRevision($pending_revision_id);
 125
 126     // Change the value of the field in the default language, save the pending
 127     // revision and check that the value of the field in the second language is
 128     // also taken from the pending revision, *not* from the default revision.
 129     $pending_revision->name = 'updated pending revision - en';
 130     $pending_revision->save();
 131
 132     $pending_revision = $storage->loadRevision($pending_revision_id);
 133
 134     $this->assertEquals($pending_revision->name->value, 'updated pending revision - en');
 135     $this->assertEquals($pending_revision->getTranslation('de')->name->value, 'pending revision - de');
 136   }
 137
 138   /**
 139    * Tests changing the default revision flag is propagated to all translations.
 140    */
 141   public function testDefaultRevision() {
 142     // Create a test entity with a translation, which will internally trigger
 143     // entity cloning for the new translation and create references for some of
 144     // the entity properties.
 145     $entity = EntityTestMulRev::create([
 146       'name' => 'original',
 147       'language' => 'en',
 148     ]);
 149     $translation = $entity->addTranslation('de');
 150     $entity->save();
 151
 152     // Assert that the entity is in the default revision.
 153     $this->assertTrue($entity->isDefaultRevision());
 154     $this->assertTrue($translation->isDefaultRevision());
 155
 156     // Change the default revision flag on one of the entity translations and
 157     // assert that the change is propagated to all entity translation objects.
 158     $translation->isDefaultRevision(FALSE);
 159     $this->assertFalse($entity->isDefaultRevision());
 160     $this->assertFalse($translation->isDefaultRevision());
 161   }
 162
 163   /**
 164    * @covers \Drupal\Core\Entity\RevisionableInterface::setNewRevision
 165    */
 166   public function testSetNewRevision() {
 167     $user = $this->createUser();
 168
 169     // All revisionable entity variations have to have the same results.
 170     foreach (entity_test_entity_types(ENTITY_TEST_TYPES_REVISABLE) as $entity_type) {
 171       $this->installEntitySchema($entity_type);
 172
 173       $entity = entity_create($entity_type, [
 174         'name' => 'foo',
 175         'user_id' => $user->id(),
 176       ]);
 177
 178       $entity->save();
 179       $entity_id = $entity->id();
 180       $entity_rev_id = $entity->getRevisionId();
 181       $entity = entity_load($entity_type, $entity_id, TRUE);
 182
 183       $entity->setNewRevision(TRUE);
 184       $entity->setNewRevision(FALSE);
 185       $entity->save();
 186       $entity = entity_load($entity_type, $entity_id, TRUE);
 187
 188       $this->assertEquals($entity_rev_id, $entity->getRevisionId(), 'A new entity revision was not created.');
 189     }
 190   }
 191
 192   /**
 193    * Tests that revision translations are correctly detected.
 194    *
 195    * @covers \Drupal\Core\Entity\ContentEntityStorageBase::isAnyStoredRevisionTranslated
 196    */
 197   public function testIsAnyStoredRevisionTranslated() {
 198     /** @var \Drupal\Core\Entity\ContentEntityStorageInterface $storage */
 199     $storage = $this->entityManager->getStorage('entity_test_mul');
 200     $method = new \ReflectionMethod(get_class($storage), 'isAnyStoredRevisionTranslated');
 201     $method->setAccessible(TRUE);
 202
 203     // Check that a non-revisionable new entity is handled correctly.
 204     $entity = EntityTestMul::create();
 205     $this->assertEmpty($entity->getTranslationLanguages(FALSE));
 206     $this->assertFalse($method->invoke($storage, $entity));
 207     $entity->addTranslation('it');
 208     $this->assertNotEmpty($entity->getTranslationLanguages(FALSE));
 209     $this->assertFalse($method->invoke($storage, $entity));
 210
 211     // Check that not yet stored translations are handled correctly.
 212     $entity = EntityTestMul::create();
 213     $entity->save();
 214     $entity->addTranslation('it');
 215     $this->assertNotEmpty($entity->getTranslationLanguages(FALSE));
 216     $this->assertFalse($method->invoke($storage, $entity));
 217
 218     // Check that removed translations are handled correctly.
 219     $entity->save();
 220     $entity->removeTranslation('it');
 221     $this->assertEmpty($entity->getTranslationLanguages(FALSE));
 222     $this->assertTrue($method->invoke($storage, $entity));
 223     $entity->save();
 224     $this->assertEmpty($entity->getTranslationLanguages(FALSE));
 225     $this->assertFalse($method->invoke($storage, $entity));
 226     $entity->addTranslation('de');
 227     $entity->removeTranslation('de');
 228     $this->assertEmpty($entity->getTranslationLanguages(FALSE));
 229     $this->assertFalse($method->invoke($storage, $entity));
 230
 231     // Check that a non-revisionable not translated entity is handled correctly.
 232     $entity = EntityTestMul::create();
 233     $entity->save();
 234     $this->assertEmpty($entity->getTranslationLanguages(FALSE));
 235     $this->assertFalse($method->invoke($storage, $entity));
 236
 237     // Check that a non-revisionable translated entity is handled correctly.
 238     $entity->addTranslation('it');
 239     $entity->save();
 240     $this->assertNotEmpty($entity->getTranslationLanguages(FALSE));
 241     $this->assertTrue($method->invoke($storage, $entity));
 242
 243     /** @var \Drupal\Core\Entity\ContentEntityStorageInterface $storage */
 244     $storage = $this->entityManager->getStorage('entity_test_mulrev');
 245
 246     // Check that a revisionable new entity is handled correctly.
 247     $entity = EntityTestMulRev::create();
 248     $this->assertEmpty($entity->getTranslationLanguages(FALSE));
 249     $this->assertFalse($method->invoke($storage, $entity));
 250     $entity->addTranslation('it');
 251     $this->assertNotEmpty($entity->getTranslationLanguages(FALSE));
 252     $this->assertFalse($method->invoke($storage, $entity));
 253
 254     // Check that a revisionable not translated entity is handled correctly.
 255     $entity = EntityTestMulRev::create();
 256     $entity->save();
 257     $this->assertEmpty($entity->getTranslationLanguages(FALSE));
 258     $this->assertFalse($method->invoke($storage, $entity));
 259
 260     // Check that a revisionable translated pending revision is handled
 261     // correctly.
 262     /** @var \Drupal\Core\Entity\ContentEntityInterface $new_revision */
 263     $new_revision = $storage->createRevision($entity, FALSE);
 264     $new_revision->addTranslation('it');
 265     $new_revision->save();
 266     /** @var \Drupal\Core\Entity\ContentEntityInterface $entity */
 267     $entity = $storage->loadUnchanged($entity->id());
 268     $this->assertEmpty($entity->getTranslationLanguages(FALSE));
 269     $this->assertNotEmpty($new_revision->getTranslationLanguages(FALSE));
 270     $this->assertTrue($method->invoke($storage, $entity));
 271
 272     // Check that a revisionable translated default revision is handled
 273     // correctly.
 274     $new_revision->isDefaultRevision(TRUE);
 275     $new_revision->save();
 276     /** @var \Drupal\Core\Entity\ContentEntityInterface $entity */
 277     $entity = $storage->loadUnchanged($entity->id());
 278     $this->assertNotEmpty($entity->getTranslationLanguages(FALSE));
 279     $this->assertNotEmpty($new_revision->getTranslationLanguages(FALSE));
 280     $this->assertTrue($method->invoke($storage, $entity));
 281   }
 282
 283 }