View source
<?php
namespace Drupal\KernelTests\Core\Entity;
use Drupal\Core\Config\Entity\ConfigEntityInterface;
use Drupal\Core\Entity\EntityTypeManagerInterface;
use Drupal\Core\Entity\EntityTypeInterface;
use Drupal\Core\Entity\TypedData\EntityDataDefinition;
use Drupal\Core\Entity\TypedData\EntityDataDefinitionInterface;
use Drupal\Core\Field\BaseFieldDefinition;
use Drupal\Core\Field\FieldDefinitionInterface;
use Drupal\Core\TypedData\ComplexDataDefinitionInterface;
use Drupal\Core\TypedData\DataReferenceDefinition;
use Drupal\Core\TypedData\DataReferenceDefinitionInterface;
use Drupal\Core\TypedData\ListDataDefinitionInterface;
use Drupal\KernelTests\KernelTestBase;
use Drupal\node\Entity\NodeType;
class EntityTypedDataDefinitionTest extends KernelTestBase {
protected $typedDataManager;
public static $modules = [
'system',
'filter',
'text',
'node',
'user',
];
protected function setUp() {
parent::setup();
$this->typedDataManager = $this->container
->get('typed_data_manager');
}
public function testFields() {
$field_definition = BaseFieldDefinition::create('integer');
$this
->assertInstanceOf(ListDataDefinitionInterface::class, $field_definition);
$this
->assertNotInstanceOf(ComplexDataDefinitionInterface::class, $field_definition);
$field_item_definition = $field_definition
->getItemDefinition();
$this
->assertNotInstanceOf(ListDataDefinitionInterface::class, $field_item_definition);
$this
->assertInstanceOf(ComplexDataDefinitionInterface::class, $field_item_definition);
$this
->assertEqual(array_keys($field_item_definition
->getPropertyDefinitions()), [
'value',
]);
$this
->assertEqual($field_item_definition
->getPropertyDefinition('value')
->getDataType(), 'integer');
$this
->assertEqual($field_item_definition
->getMainPropertyName(), 'value');
$this
->assertNull($field_item_definition
->getPropertyDefinition('invalid'));
$this
->assertInstanceOf(FieldDefinitionInterface::class, $field_definition);
$this
->assertEqual(array_keys($field_definition
->getPropertyDefinitions()), [
'value',
]);
$this
->assertEqual($field_definition
->getPropertyDefinition('value')
->getDataType(), 'integer');
$this
->assertEqual($field_definition
->getMainPropertyName(), 'value');
$this
->assertNull($field_definition
->getPropertyDefinition('invalid'));
$field_item = $this->typedDataManager
->createDataDefinition('field_item:integer');
$this
->assertNotInstanceOf(ListDataDefinitionInterface::class, $field_item);
$this
->assertInstanceOf(ComplexDataDefinitionInterface::class, $field_item);
$this
->assertEqual(serialize($field_item_definition), serialize($field_item));
$field_definition2 = $this->typedDataManager
->createListDataDefinition('field_item:integer');
$this
->assertInstanceOf(ListDataDefinitionInterface::class, $field_definition2);
$this
->assertNotInstanceOf(ComplexDataDefinitionInterface::class, $field_definition2);
$this
->assertEqual(serialize($field_definition), serialize($field_definition2));
}
public function testEntities() {
NodeType::create([
'type' => 'article',
'name' => 'Article',
])
->save();
$entity_definition = EntityDataDefinition::create('node');
$bundle_definition = EntityDataDefinition::create('node', 'article');
$this
->assertNotInstanceOf(ListDataDefinitionInterface::class, $entity_definition);
$this
->assertInstanceOf(ComplexDataDefinitionInterface::class, $entity_definition);
$this
->assertEquals('Content', $entity_definition
->getLabel());
$this
->assertEquals('Article', $bundle_definition
->getLabel());
$field_definitions = $entity_definition
->getPropertyDefinitions();
$this
->assertEqual(serialize($field_definitions), serialize(\Drupal::service('entity_field.manager')
->getBaseFieldDefinitions('node')));
$this
->assertEqual($entity_definition
->getPropertyDefinition('title')
->getItemDefinition()
->getDataType(), 'field_item:string');
$this
->assertNull($entity_definition
->getMainPropertyName());
$this
->assertNull($entity_definition
->getPropertyDefinition('invalid'));
$entity_definition2 = $this->typedDataManager
->createDataDefinition('entity:node');
$this
->assertNotInstanceOf(ListDataDefinitionInterface::class, $entity_definition2);
$this
->assertInstanceOf(ComplexDataDefinitionInterface::class, $entity_definition2);
$this
->assertEqual(serialize($entity_definition), serialize($entity_definition2));
$this
->assertEqual(serialize($this->typedDataManager
->createDataDefinition('entity')), serialize(EntityDataDefinition::create()));
$this
->assertEqual(serialize($this->typedDataManager
->createDataDefinition('entity:node')), serialize(EntityDataDefinition::create('node')));
$entity_definition = EntityDataDefinition::create('node_type');
$this
->assertEqual([], $entity_definition
->getPropertyDefinitions());
}
public function testEntityReferences() {
$reference_definition = DataReferenceDefinition::create('entity');
$this
->assertInstanceOf(DataReferenceDefinitionInterface::class, $reference_definition);
$this
->assertEqual($reference_definition
->getTargetDefinition()
->getDataType(), 'entity');
$this
->assertInstanceOf(EntityDataDefinitionInterface::class, $reference_definition
->getTargetDefinition());
$reference_definition2 = $this->typedDataManager
->createDataDefinition('entity_reference');
$this
->assertInstanceOf(DataReferenceDefinitionInterface::class, $reference_definition2);
$this
->assertEqual(serialize($reference_definition2), serialize($reference_definition));
}
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
->getKey('bundle')
->willReturn(FALSE);
$entity_type
->getLabel()
->willReturn($this
->randomString());
$entity_type
->getConstraints()
->willReturn([]);
$entity_type
->isInternal()
->willReturn($internal);
$entity_type
->getBundleEntityType()
->willReturn(NULL);
$entity_type_manager = $this
->prophesize(EntityTypeManagerInterface::class);
$entity_type_manager
->getDefinitions()
->willReturn([
$entity_type_id => $entity_type
->reveal(),
]);
$this->container
->set('entity_type.manager', $entity_type_manager
->reveal());
$entity_data_definition = EntityDataDefinition::create($entity_type_id);
$this
->assertSame($expected, $entity_data_definition
->isInternal());
}
public function entityDefinitionIsInternalProvider() {
return [
'internal' => [
TRUE,
TRUE,
],
'external' => [
FALSE,
FALSE,
],
'undefined' => [
NULL,
FALSE,
],
];
}
}