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

   1 <?php
   2
   3 namespace Drupal\KernelTests\Core\Entity;
   4
   5 use Drupal\Core\Config\Entity\ConfigEntityInterface;
   6 use Drupal\Core\Entity\EntityManagerInterface;
   7 use Drupal\Core\Entity\EntityTypeInterface;
   8 use Drupal\Core\Entity\TypedData\EntityDataDefinition;
   9 use Drupal\Core\Entity\TypedData\EntityDataDefinitionInterface;
  10 use Drupal\Core\Field\BaseFieldDefinition;
  11 use Drupal\Core\Field\FieldDefinitionInterface;
  12 use Drupal\Core\TypedData\ComplexDataDefinitionInterface;
  13 use Drupal\Core\TypedData\DataReferenceDefinition;
  14 use Drupal\Core\TypedData\DataReferenceDefinitionInterface;
  15 use Drupal\Core\TypedData\ListDataDefinitionInterface;
  16 use Drupal\KernelTests\KernelTestBase;
  17 use Drupal\node\Entity\NodeType;
  18
  19 /**
  20  * Tests deriving metadata of entity and field data types.
  21  *
  22  * @group Entity
  23  */
  24 class EntityTypedDataDefinitionTest extends KernelTestBase {
  25
  26   /**
  27    * The typed data manager to use.
  28    *
  29    * @var \Drupal\Core\TypedData\TypedDataManager
  30    */
  31   protected $typedDataManager;
  32
  33   /**
  34    * Modules to enable.
  35    *
  36    * @var array
  37    */
  38   public static $modules = ['system', 'filter', 'text', 'node', 'user'];
  39
  40   protected function setUp() {
  41     parent::setup();
  42
  43     $this->typedDataManager = $this->container->get('typed_data_manager');
  44   }
  45
  46   /**
  47    * Tests deriving metadata about fields.
  48    */
  49   public function testFields() {
  50     $field_definition = BaseFieldDefinition::create('integer');
  51     // Fields are lists of complex data.
  52     $this->assertTrue($field_definition instanceof ListDataDefinitionInterface);
  53     $this->assertFalse($field_definition instanceof ComplexDataDefinitionInterface);
  54     $field_item_definition = $field_definition->getItemDefinition();
  55     $this->assertFalse($field_item_definition instanceof ListDataDefinitionInterface);
  56     $this->assertTrue($field_item_definition instanceof ComplexDataDefinitionInterface);
  57
  58     // Derive metadata about field item properties.
  59     $this->assertEqual(array_keys($field_item_definition->getPropertyDefinitions()), ['value']);
  60     $this->assertEqual($field_item_definition->getPropertyDefinition('value')->getDataType(), 'integer');
  61     $this->assertEqual($field_item_definition->getMainPropertyName(), 'value');
  62     $this->assertNull($field_item_definition->getPropertyDefinition('invalid'));
  63
  64     // Test accessing field item property metadata via the field definition.
  65     $this->assertTrue($field_definition instanceof FieldDefinitionInterface);
  66     $this->assertEqual(array_keys($field_definition->getPropertyDefinitions()), ['value']);
  67     $this->assertEqual($field_definition->getPropertyDefinition('value')->getDataType(), 'integer');
  68     $this->assertEqual($field_definition->getMainPropertyName(), 'value');
  69     $this->assertNull($field_definition->getPropertyDefinition('invalid'));
  70
  71     // Test using the definition factory for field item lists and field items.
  72     $field_item = $this->typedDataManager->createDataDefinition('field_item:integer');
  73     $this->assertFalse($field_item instanceof ListDataDefinitionInterface);
  74     $this->assertTrue($field_item instanceof ComplexDataDefinitionInterface);
  75     // Comparison should ignore the internal static cache, so compare the
  76     // serialized objects instead.
  77     $this->assertEqual(serialize($field_item_definition), serialize($field_item));
  78
  79     $field_definition2 = $this->typedDataManager->createListDataDefinition('field_item:integer');
  80     $this->assertTrue($field_definition2 instanceof ListDataDefinitionInterface);
  81     $this->assertFalse($field_definition2 instanceof ComplexDataDefinitionInterface);
  82     $this->assertEqual(serialize($field_definition), serialize($field_definition2));
  83   }
  84
  85   /**
  86    * Tests deriving metadata about entities.
  87    */
  88   public function testEntities() {
  89     NodeType::create([
  90       'type' => 'article',
  91       'name' => 'Article',
  92     ])->save();
  93
  94     $entity_definition = EntityDataDefinition::create('node');
  95     $bundle_definition = EntityDataDefinition::create('node', 'article');
  96     // Entities are complex data.
  97     $this->assertFalse($entity_definition instanceof ListDataDefinitionInterface);
  98     $this->assertTrue($entity_definition instanceof ComplexDataDefinitionInterface);
  99
 100     // Entity definitions should inherit their labels from the entity type.
 101     $this->assertEquals('Content', $entity_definition->getLabel());
 102     $this->assertEquals('Article', $bundle_definition->getLabel());
 103
 104     $field_definitions = $entity_definition->getPropertyDefinitions();
 105     // Comparison should ignore the internal static cache, so compare the
 106     // serialized objects instead.
 107     $this->assertEqual(serialize($field_definitions), serialize(\Drupal::entityManager()->getBaseFieldDefinitions('node')));
 108     $this->assertEqual($entity_definition->getPropertyDefinition('title')->getItemDefinition()->getDataType(), 'field_item:string');
 109     $this->assertNull($entity_definition->getMainPropertyName());
 110     $this->assertNull($entity_definition->getPropertyDefinition('invalid'));
 111
 112     $entity_definition2 = $this->typedDataManager->createDataDefinition('entity:node');
 113     $this->assertFalse($entity_definition2 instanceof ListDataDefinitionInterface);
 114     $this->assertTrue($entity_definition2 instanceof ComplexDataDefinitionInterface);
 115     $this->assertEqual(serialize($entity_definition), serialize($entity_definition2));
 116
 117     // Test that the definition factory creates the right definitions for all
 118     // entity data types variants.
 119     $this->assertEqual(serialize($this->typedDataManager->createDataDefinition('entity')), serialize(EntityDataDefinition::create()));
 120     $this->assertEqual(serialize($this->typedDataManager->createDataDefinition('entity:node')), serialize(EntityDataDefinition::create('node')));
 121
 122     // Config entities don't support typed data.
 123     $entity_definition = EntityDataDefinition::create('node_type');
 124     $this->assertEqual([], $entity_definition->getPropertyDefinitions());
 125   }
 126
 127   /**
 128    * Tests deriving metadata from entity references.
 129    */
 130   public function testEntityReferences() {
 131     $reference_definition = DataReferenceDefinition::create('entity');
 132     $this->assertTrue($reference_definition instanceof DataReferenceDefinitionInterface);
 133
 134     // Test retrieving metadata about the referenced data.
 135     $this->assertEqual($reference_definition->getTargetDefinition()->getDataType(), 'entity');
 136     $this->assertTrue($reference_definition->getTargetDefinition() instanceof EntityDataDefinitionInterface);
 137
 138     // Test that the definition factory creates the right definition object.
 139     $reference_definition2 = $this->typedDataManager->createDataDefinition('entity_reference');
 140     $this->assertTrue($reference_definition2 instanceof DataReferenceDefinitionInterface);
 141     $this->assertEqual(serialize($reference_definition2), serialize($reference_definition));
 142   }
 143
 144   /**
 145    * Tests that an entity annotation can mark the data definition as internal.
 146    *
 147    * @dataProvider entityDefinitionIsInternalProvider
 148    */
 149   public function testEntityDefinitionIsInternal($internal, $expected) {
 150     $entity_type_id = $this->randomMachineName();
 151
 152     $entity_type = $this->prophesize(EntityTypeInterface::class);
 153     $entity_type->entityClassImplements(ConfigEntityInterface::class)->willReturn(FALSE);
 154     $entity_type->getLabel()->willReturn($this->randomString());
 155     $entity_type->getConstraints()->willReturn([]);
 156     $entity_type->isInternal()->willReturn($internal);
 157
 158     $entity_manager = $this->prophesize(EntityManagerInterface::class);
 159     $entity_manager->getDefinitions()->willReturn([$entity_type_id => $entity_type->reveal()]);
 160     $this->container->set('entity.manager', $entity_manager->reveal());
 161
 162     $entity_data_definition = EntityDataDefinition::create($entity_type_id);
 163     $this->assertSame($expected, $entity_data_definition->isInternal());
 164   }
 165
 166   /**
 167    * Provides test cases for testEntityDefinitionIsInternal.
 168    */
 169   public function entityDefinitionIsInternalProvider() {
 170     return [
 171       'internal' => [TRUE, TRUE],
 172       'external' => [FALSE, FALSE],
 173       'undefined' => [NULL, FALSE],
 174     ];
 175   }
 176
 177 }