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\Entity\TypedData\EntityDataDefinition;
   6 use Drupal\Core\Entity\TypedData\EntityDataDefinitionInterface;
   7 use Drupal\Core\Field\BaseFieldDefinition;
   8 use Drupal\Core\Field\FieldDefinitionInterface;
   9 use Drupal\Core\TypedData\ComplexDataDefinitionInterface;
  10 use Drupal\Core\TypedData\DataReferenceDefinition;
  11 use Drupal\Core\TypedData\DataReferenceDefinitionInterface;
  12 use Drupal\Core\TypedData\ListDataDefinitionInterface;
  13 use Drupal\KernelTests\KernelTestBase;
  14
  15 /**
  16  * Tests deriving metadata of entity and field data types.
  17  *
  18  * @group Entity
  19  */
  20 class EntityTypedDataDefinitionTest extends KernelTestBase {
  21
  22   /**
  23    * The typed data manager to use.
  24    *
  25    * @var \Drupal\Core\TypedData\TypedDataManager
  26    */
  27   protected $typedDataManager;
  28
  29   /**
  30    * Modules to enable.
  31    *
  32    * @var array
  33    */
  34   public static $modules = ['filter', 'text', 'node', 'user'];
  35
  36   protected function setUp() {
  37     parent::setup();
  38     $this->typedDataManager = $this->container->get('typed_data_manager');
  39   }
  40
  41   /**
  42    * Tests deriving metadata about fields.
  43    */
  44   public function testFields() {
  45     $field_definition = BaseFieldDefinition::create('integer');
  46     // Fields are lists of complex data.
  47     $this->assertTrue($field_definition instanceof ListDataDefinitionInterface);
  48     $this->assertFalse($field_definition instanceof ComplexDataDefinitionInterface);
  49     $field_item_definition = $field_definition->getItemDefinition();
  50     $this->assertFalse($field_item_definition instanceof ListDataDefinitionInterface);
  51     $this->assertTrue($field_item_definition instanceof ComplexDataDefinitionInterface);
  52
  53     // Derive metadata about field item properties.
  54     $this->assertEqual(array_keys($field_item_definition->getPropertyDefinitions()), ['value']);
  55     $this->assertEqual($field_item_definition->getPropertyDefinition('value')->getDataType(), 'integer');
  56     $this->assertEqual($field_item_definition->getMainPropertyName(), 'value');
  57     $this->assertNull($field_item_definition->getPropertyDefinition('invalid'));
  58
  59     // Test accessing field item property metadata via the field definition.
  60     $this->assertTrue($field_definition instanceof FieldDefinitionInterface);
  61     $this->assertEqual(array_keys($field_definition->getPropertyDefinitions()), ['value']);
  62     $this->assertEqual($field_definition->getPropertyDefinition('value')->getDataType(), 'integer');
  63     $this->assertEqual($field_definition->getMainPropertyName(), 'value');
  64     $this->assertNull($field_definition->getPropertyDefinition('invalid'));
  65
  66     // Test using the definition factory for field item lists and field items.
  67     $field_item = $this->typedDataManager->createDataDefinition('field_item:integer');
  68     $this->assertFalse($field_item instanceof ListDataDefinitionInterface);
  69     $this->assertTrue($field_item instanceof ComplexDataDefinitionInterface);
  70     // Comparison should ignore the internal static cache, so compare the
  71     // serialized objects instead.
  72     $this->assertEqual(serialize($field_item_definition), serialize($field_item));
  73
  74     $field_definition2 = $this->typedDataManager->createListDataDefinition('field_item:integer');
  75     $this->assertTrue($field_definition2 instanceof ListDataDefinitionInterface);
  76     $this->assertFalse($field_definition2 instanceof ComplexDataDefinitionInterface);
  77     $this->assertEqual(serialize($field_definition), serialize($field_definition2));
  78   }
  79
  80   /**
  81    * Tests deriving metadata about entities.
  82    */
  83   public function testEntities() {
  84     $entity_definition = EntityDataDefinition::create('node');
  85     // Entities are complex data.
  86     $this->assertFalse($entity_definition instanceof ListDataDefinitionInterface);
  87     $this->assertTrue($entity_definition instanceof ComplexDataDefinitionInterface);
  88
  89     $field_definitions = $entity_definition->getPropertyDefinitions();
  90     // Comparison should ignore the internal static cache, so compare the
  91     // serialized objects instead.
  92     $this->assertEqual(serialize($field_definitions), serialize(\Drupal::entityManager()->getBaseFieldDefinitions('node')));
  93     $this->assertEqual($entity_definition->getPropertyDefinition('title')->getItemDefinition()->getDataType(), 'field_item:string');
  94     $this->assertNull($entity_definition->getMainPropertyName());
  95     $this->assertNull($entity_definition->getPropertyDefinition('invalid'));
  96
  97     $entity_definition2 = $this->typedDataManager->createDataDefinition('entity:node');
  98     $this->assertFalse($entity_definition2 instanceof ListDataDefinitionInterface);
  99     $this->assertTrue($entity_definition2 instanceof ComplexDataDefinitionInterface);
 100     $this->assertEqual(serialize($entity_definition), serialize($entity_definition2));
 101
 102     // Test that the definition factory creates the right definitions for all
 103     // entity data types variants.
 104     $this->assertEqual(serialize($this->typedDataManager->createDataDefinition('entity')), serialize(EntityDataDefinition::create()));
 105     $this->assertEqual(serialize($this->typedDataManager->createDataDefinition('entity:node')), serialize(EntityDataDefinition::create('node')));
 106
 107     // Config entities don't support typed data.
 108     $entity_definition = EntityDataDefinition::create('node_type');
 109     $this->assertEqual([], $entity_definition->getPropertyDefinitions());
 110   }
 111
 112   /**
 113    * Tests deriving metadata from entity references.
 114    */
 115   public function testEntityReferences() {
 116     $reference_definition = DataReferenceDefinition::create('entity');
 117     $this->assertTrue($reference_definition instanceof DataReferenceDefinitionInterface);
 118
 119     // Test retrieving metadata about the referenced data.
 120     $this->assertEqual($reference_definition->getTargetDefinition()->getDataType(), 'entity');
 121     $this->assertTrue($reference_definition->getTargetDefinition() instanceof EntityDataDefinitionInterface);
 122
 123     // Test that the definition factory creates the right definition object.
 124     $reference_definition2 = $this->typedDataManager->createDataDefinition('entity_reference');
 125     $this->assertTrue($reference_definition2 instanceof DataReferenceDefinitionInterface);
 126     $this->assertEqual(serialize($reference_definition2), serialize($reference_definition));
 127   }
 128
 129 }