Updated Drupal to 8.6. This goes with the following updates because it's possible...

[yaffs-website] / web / core / tests / Drupal / KernelTests / Core / Entity / EntityTypedDataDefinitionTest.php

diff --git a/web/core/tests/Drupal/KernelTests/Core/Entity/EntityTypedDataDefinitionTest.php b/web/core/tests/Drupal/KernelTests/Core/Entity/EntityTypedDataDefinitionTest.php
index 9d5095d1494b9712d51bd84c0fdb62a72b9784c7..d0c01bccb5d8727121da0d42885539df5c443a3d 100644 (file)
--- a/web/core/tests/Drupal/KernelTests/Core/Entity/EntityTypedDataDefinitionTest.php
+++ b/web/core/tests/Drupal/KernelTests/Core/Entity/EntityTypedDataDefinitionTest.php
@@ -2,6 +2,9 @@
 
 namespace Drupal\KernelTests\Core\Entity;
 
+use Drupal\Core\Config\Entity\ConfigEntityInterface;
+use Drupal\Core\Entity\EntityManagerInterface;
+use Drupal\Core\Entity\EntityTypeInterface;
 use Drupal\Core\Entity\TypedData\EntityDataDefinition;
 use Drupal\Core\Entity\TypedData\EntityDataDefinitionInterface;
 use Drupal\Core\Field\BaseFieldDefinition;
@@ -11,6 +14,7 @@ use Drupal\Core\TypedData\DataReferenceDefinition;
 use Drupal\Core\TypedData\DataReferenceDefinitionInterface;
 use Drupal\Core\TypedData\ListDataDefinitionInterface;
 use Drupal\KernelTests\KernelTestBase;
+use Drupal\node\Entity\NodeType;
 
 /**
  * Tests deriving metadata of entity and field data types.
@@ -31,10 +35,11 @@ class EntityTypedDataDefinitionTest extends KernelTestBase {
    *
    * @var array
    */
-  public static $modules = ['filter', 'text', 'node', 'user'];
+  public static $modules = ['system', 'filter', 'text', 'node', 'user'];
 
   protected function setUp() {
     parent::setup();
+
     $this->typedDataManager = $this->container->get('typed_data_manager');
   }
 
@@ -81,11 +86,21 @@ class EntityTypedDataDefinitionTest extends KernelTestBase {
    * Tests deriving metadata about entities.
    */
   public function testEntities() {
+    NodeType::create([
+      'type' => 'article',
+      'name' => 'Article',
+    ])->save();
+
     $entity_definition = EntityDataDefinition::create('node');
+    $bundle_definition = EntityDataDefinition::create('node', 'article');
     // Entities are complex data.
     $this->assertFalse($entity_definition instanceof ListDataDefinitionInterface);
     $this->assertTrue($entity_definition instanceof ComplexDataDefinitionInterface);
 
+    // Entity definitions should inherit their labels from the entity type.
+    $this->assertEquals('Content', $entity_definition->getLabel());
+    $this->assertEquals('Article', $bundle_definition->getLabel());
+
     $field_definitions = $entity_definition->getPropertyDefinitions();
     // Comparison should ignore the internal static cache, so compare the
     // serialized objects instead.
@@ -101,8 +116,8 @@ class EntityTypedDataDefinitionTest extends KernelTestBase {
 
     // Test that the definition factory creates the right definitions for all
     // entity data types variants.
-    $this->assertEqual($this->typedDataManager->createDataDefinition('entity'), EntityDataDefinition::create());
-    $this->assertEqual($this->typedDataManager->createDataDefinition('entity:node'), EntityDataDefinition::create('node'));
+    $this->assertEqual(serialize($this->typedDataManager->createDataDefinition('entity')), serialize(EntityDataDefinition::create()));
+    $this->assertEqual(serialize($this->typedDataManager->createDataDefinition('entity:node')), serialize(EntityDataDefinition::create('node')));
 
     // Config entities don't support typed data.
     $entity_definition = EntityDataDefinition::create('node_type');
@@ -123,7 +138,40 @@ class EntityTypedDataDefinitionTest extends KernelTestBase {
     // Test that the definition factory creates the right definition object.
     $reference_definition2 = $this->typedDataManager->createDataDefinition('entity_reference');
     $this->assertTrue($reference_definition2 instanceof DataReferenceDefinitionInterface);
-    $this->assertEqual($reference_definition2, $reference_definition);
+    $this->assertEqual(serialize($reference_definition2), serialize($reference_definition));
+  }
+
+  /**
+   * Tests that an entity annotation can mark the data definition as internal.
+   *
+   * @dataProvider entityDefinitionIsInternalProvider
+   */
+  public function testEntityDefinitionIsInternal($internal, $expected) {
+    $entity_type_id = $this->randomMachineName();
+
+    $entity_type = $this->prophesize(EntityTypeInterface::class);
+    $entity_type->entityClassImplements(ConfigEntityInterface::class)->willReturn(FALSE);
+    $entity_type->getLabel()->willReturn($this->randomString());
+    $entity_type->getConstraints()->willReturn([]);
+    $entity_type->isInternal()->willReturn($internal);
+
+    $entity_manager = $this->prophesize(EntityManagerInterface::class);
+    $entity_manager->getDefinitions()->willReturn([$entity_type_id => $entity_type->reveal()]);
+    $this->container->set('entity.manager', $entity_manager->reveal());
+
+    $entity_data_definition = EntityDataDefinition::create($entity_type_id);
+    $this->assertSame($expected, $entity_data_definition->isInternal());
+  }
+
+  /**
+   * Provides test cases for testEntityDefinitionIsInternal.
+   */
+  public function entityDefinitionIsInternalProvider() {
+    return [
+      'internal' => [TRUE, TRUE],
+      'external' => [FALSE, FALSE],
+      'undefined' => [NULL, FALSE],
+    ];
   }
 
 }