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