5 * Contains \Drupal\Tests\views\Unit\EntityViewsDataTest.
8 namespace Drupal\Tests\views\Unit;
10 use Drupal\Core\Config\Entity\ConfigEntityType;
11 use Drupal\Core\Entity\ContentEntityType;
12 use Drupal\Core\Entity\EntityTypeInterface;
13 use Drupal\Core\Entity\Sql\DefaultTableMapping;
14 use Drupal\Core\Field\BaseFieldDefinition;
15 use Drupal\Core\Field\Plugin\Field\FieldType\EntityReferenceItem;
16 use Drupal\Core\Field\Plugin\Field\FieldType\IntegerItem;
17 use Drupal\Core\Field\Plugin\Field\FieldType\LanguageItem;
18 use Drupal\Core\Field\Plugin\Field\FieldType\StringItem;
19 use Drupal\Core\Field\Plugin\Field\FieldType\UriItem;
20 use Drupal\Core\Field\Plugin\Field\FieldType\UuidItem;
21 use Drupal\Core\TypedData\TypedDataManagerInterface;
22 use Drupal\text\Plugin\Field\FieldType\TextLongItem;
23 use Drupal\entity_test\Entity\EntityTest;
24 use Drupal\entity_test\Entity\EntityTestMul;
25 use Drupal\entity_test\Entity\EntityTestMulRev;
26 use Drupal\Tests\UnitTestCase;
27 use Drupal\views\EntityViewsData;
28 use Symfony\Component\DependencyInjection\ContainerBuilder;
31 * @coversDefaultClass \Drupal\views\EntityViewsData
34 class EntityViewsDataTest extends UnitTestCase {
37 * Entity info to use in this test.
39 * @var \Drupal\Core\Entity\EntityTypeInterface|\Drupal\Tests\views\Unit\TestEntityType
41 protected $baseEntityType;
44 * The mocked entity storage.
46 * @var \Drupal\Core\Entity\Sql\SqlContentEntityStorage|\PHPUnit_Framework_MockObject_MockObject
48 protected $entityStorage;
51 * The mocked entity manager.
53 * @var \Drupal\Core\Entity\EntityManagerInterface|\PHPUnit_Framework_MockObject_MockObject
55 protected $entityManager;
58 * The mocked module handler.
60 * @var \Drupal\Core\Extension\ModuleHandlerInterface|\PHPUnit_Framework_MockObject_MockObject
62 protected $moduleHandler;
65 * The mocked translation manager.
67 * @var \Drupal\Core\StringTranslation\TranslationInterface|\PHPUnit_Framework_MockObject_MockObject
69 protected $translationManager;
72 * The tested entity views controller.
74 * @var \Drupal\Tests\views\Unit\TestEntityViewsData
81 protected function setUp() {
82 $this->entityStorage = $this->getMockBuilder('Drupal\Core\Entity\Sql\SqlContentEntityStorage')
83 ->disableOriginalConstructor()
85 $this->entityManager = $this->getMock('Drupal\Core\Entity\EntityManagerInterface');
87 $typed_data_manager = $this->getMock(TypedDataManagerInterface::class);
88 $typed_data_manager->expects($this->any())
89 ->method('createDataDefinition')
90 ->willReturn($this->getMock('Drupal\Core\TypedData\DataDefinitionInterface'));
92 $typed_data_manager->expects($this->any())
93 ->method('getDefinition')
94 ->with($this->equalTo('field_item:string_long'))
95 ->willReturn(['class' => '\Drupal\Core\Field\Plugin\Field\FieldType\StringLongItem']);
97 $this->baseEntityType = new TestEntityType([
98 'base_table' => 'entity_test',
99 'id' => 'entity_test',
100 'label' => 'Entity test',
104 'langcode' => 'langcode',
106 'revision' => 'revision_id',
108 'provider' => 'entity_test',
109 'list_cache_contexts' => ['entity_test_list_cache_context'],
112 $this->translationManager = $this->getStringTranslationStub();
113 $this->moduleHandler = $this->getMock('Drupal\Core\Extension\ModuleHandlerInterface');
115 $this->viewsData = new TestEntityViewsData($this->baseEntityType, $this->entityStorage, $this->entityManager, $this->moduleHandler, $this->translationManager);
117 $field_type_manager = $this->getMockBuilder('Drupal\Core\Field\FieldTypePluginManager')
118 ->disableOriginalConstructor()
120 $field_type_manager->expects($this->any())
121 ->method('getDefaultStorageSettings')
123 $field_type_manager->expects($this->any())
124 ->method('getDefaultFieldSettings')
127 $container = new ContainerBuilder();
128 $container->set('plugin.manager.field.field_type', $field_type_manager);
129 $container->set('entity.manager', $this->entityManager);
130 $container->set('typed_data_manager', $typed_data_manager);
131 \Drupal::setContainer($container);
135 * Helper method to setup base fields.
137 * @param \Drupal\Core\Field\BaseFieldDefinition[] $base_fields
138 * The base fields which are adapted.
140 * @return \Drupal\Core\Field\BaseFieldDefinition[]
141 * The setup base fields.
143 protected function setupBaseFields(array $base_fields) {
144 // Add a description field to the fields supplied by the EntityTest
145 // classes. This example comes from the taxonomy Term entity.
146 $base_fields['description'] = BaseFieldDefinition::create('text_long')
147 ->setLabel('Description')
148 ->setDescription('A description of the term.')
149 ->setTranslatable(TRUE)
150 ->setDisplayOptions('view', [
152 'type' => 'text_default',
155 ->setDisplayConfigurable('view', TRUE)
156 ->setDisplayOptions('form', [
157 'type' => 'text_textfield',
160 ->setDisplayConfigurable('form', TRUE);
162 // Add a URL field; this example is from the Comment entity.
163 $base_fields['homepage'] = BaseFieldDefinition::create('uri')
164 ->setLabel('Homepage')
165 ->setDescription("The comment author's home page address.")
166 ->setTranslatable(TRUE)
167 ->setSetting('max_length', 255);
169 // A base field with cardinality > 1
170 $base_fields['string'] = BaseFieldDefinition::create('string')
172 ->setTranslatable(TRUE)
175 foreach ($base_fields as $name => $base_field) {
176 $base_field->setName($name);
184 public function testBaseTables() {
185 $data = $this->viewsData->getViewsData();
187 $this->assertEquals('entity_test', $data['entity_test']['table']['entity type']);
188 $this->assertEquals(FALSE, $data['entity_test']['table']['entity revision']);
189 $this->assertEquals('Entity test', $data['entity_test']['table']['group']);
190 $this->assertEquals('entity_test', $data['entity_test']['table']['provider']);
192 $this->assertEquals('id', $data['entity_test']['table']['base']['field']);
193 $this->assertEquals(['entity_test_list_cache_context'], $data['entity_test']['table']['base']['cache_contexts']);
194 $this->assertEquals('Entity test', $data['entity_test']['table']['base']['title']);
196 $this->assertFalse(isset($data['entity_test']['table']['defaults']));
198 $this->assertFalse(isset($data['entity_test_mul_property_data']));
199 $this->assertFalse(isset($data['revision_table']));
200 $this->assertFalse(isset($data['revision_data_table']));
204 * Tests data_table support.
206 public function testDataTable() {
207 $entity_type = $this->baseEntityType
208 ->set('data_table', 'entity_test_mul_property_data')
209 ->set('id', 'entity_test_mul')
210 ->set('translatable', TRUE)
211 ->setKey('label', 'label');
213 $this->viewsData->setEntityType($entity_type);
215 // Tests the join definition between the base and the data table.
216 $data = $this->viewsData->getViewsData();
217 $base_views_data = $data['entity_test'];
219 // Ensure that the base table is set to the data table.
220 $this->assertEquals('id', $data['entity_test_mul_property_data']['table']['base']['field']);
221 $this->assertEquals('Entity test', $data['entity_test_mul_property_data']['table']['base']['title']);
222 $this->assertFalse(isset($data['entity_test']['table']['base']));
224 $this->assertEquals('entity_test_mul', $data['entity_test_mul_property_data']['table']['entity type']);
225 $this->assertEquals(FALSE, $data['entity_test_mul_property_data']['table']['entity revision']);
226 $this->assertEquals('Entity test', $data['entity_test_mul_property_data']['table']['group']);
227 $this->assertEquals('entity_test', $data['entity_test']['table']['provider']);
228 $this->assertEquals(['field' => 'label', 'table' => 'entity_test_mul_property_data'], $data['entity_test_mul_property_data']['table']['base']['defaults']);
230 // Ensure the join information is set up properly.
231 $this->assertCount(1, $base_views_data['table']['join']);
232 $this->assertEquals(['entity_test_mul_property_data' => ['left_field' => 'id', 'field' => 'id', 'type' => 'INNER']], $base_views_data['table']['join']);
233 $this->assertFalse(isset($data['revision_table']));
234 $this->assertFalse(isset($data['revision_data_table']));
238 * Tests revision table without data table support.
240 public function testRevisionTableWithoutDataTable() {
241 $entity_type = $this->baseEntityType
242 ->set('revision_table', 'entity_test_mulrev_revision')
243 ->set('revision_data_table', NULL)
244 ->set('id', 'entity_test_mulrev')
245 ->setKey('revision', 'revision_id');
246 $this->viewsData->setEntityType($entity_type);
248 $data = $this->viewsData->getViewsData();
250 $this->assertEquals('Entity test revisions', $data['entity_test_mulrev_revision']['table']['base']['title']);
251 $this->assertEquals('revision_id', $data['entity_test_mulrev_revision']['table']['base']['field']);
253 $this->assertEquals(FALSE, $data['entity_test']['table']['entity revision']);
254 $this->assertEquals('entity_test_mulrev', $data['entity_test_mulrev_revision']['table']['entity type']);
255 $this->assertEquals(TRUE, $data['entity_test_mulrev_revision']['table']['entity revision']);
256 $this->assertEquals('entity_test_mulrev', $data['entity_test_mulrev_revision']['table']['entity type']);
257 $this->assertEquals(TRUE, $data['entity_test_mulrev_revision']['table']['entity revision']);
259 $this->assertEquals('Entity test revision', $data['entity_test_mulrev_revision']['table']['group']);
260 $this->assertEquals('entity_test', $data['entity_test']['table']['provider']);
262 // Ensure the join information is set up properly.
263 // Tests the join definition between the base and the revision table.
264 $revision_data = $data['entity_test_mulrev_revision'];
265 $this->assertCount(1, $revision_data['table']['join']);
266 $this->assertEquals(['entity_test' => ['left_field' => 'revision_id', 'field' => 'revision_id', 'type' => 'INNER']], $revision_data['table']['join']);
267 $this->assertFalse(isset($data['data_table']));
271 * Tests revision table with data table support.
273 public function testRevisionTableWithRevisionDataTableAndDataTable() {
274 $entity_type = $this->baseEntityType
275 ->set('data_table', 'entity_test_mul_property_data')
276 ->set('revision_table', 'entity_test_mulrev_revision')
277 ->set('revision_data_table', 'entity_test_mulrev_property_revision')
278 ->set('id', 'entity_test_mulrev')
279 ->set('translatable', TRUE)
280 ->setKey('revision', 'revision_id');
281 $this->viewsData->setEntityType($entity_type);
283 $data = $this->viewsData->getViewsData();
285 $this->assertEquals('Entity test revisions', $data['entity_test_mulrev_property_revision']['table']['base']['title']);
286 $this->assertEquals('revision_id', $data['entity_test_mulrev_property_revision']['table']['base']['field']);
287 $this->assertFalse(isset($data['entity_test_mulrev_revision']['table']['base']));
289 $this->assertEquals('entity_test_mulrev', $data['entity_test_mulrev_property_revision']['table']['entity type']);
290 $this->assertEquals('Entity test revision', $data['entity_test_mulrev_revision']['table']['group']);
291 $this->assertEquals('entity_test', $data['entity_test']['table']['provider']);
293 // Ensure the join information is set up properly.
294 // Tests the join definition between the base and the revision table.
295 $revision_field_data = $data['entity_test_mulrev_property_revision'];
296 $this->assertCount(1, $revision_field_data['table']['join']);
297 $this->assertEquals([
298 'entity_test_mul_property_data' => [
299 'left_field' => 'revision_id',
300 'field' => 'revision_id',
303 ], $revision_field_data['table']['join']);
305 $revision_base_data = $data['entity_test_mulrev_revision'];
306 $this->assertCount(1, $revision_base_data['table']['join']);
307 $this->assertEquals([
308 'entity_test_mulrev_property_revision' => [
309 'left_field' => 'revision_id',
310 'field' => 'revision_id',
313 ], $revision_base_data['table']['join']);
315 $this->assertFalse(isset($data['data_table']));
319 * Tests revision table with data table support.
321 public function testRevisionTableWithRevisionDataTable() {
322 $entity_type = $this->baseEntityType
323 ->set('revision_table', 'entity_test_mulrev_revision')
324 ->set('revision_data_table', 'entity_test_mulrev_property_revision')
325 ->set('id', 'entity_test_mulrev')
326 ->set('translatable', TRUE)
327 ->setKey('revision', 'revision_id');
328 $this->viewsData->setEntityType($entity_type);
330 $data = $this->viewsData->getViewsData();
332 $this->assertEquals('Entity test revisions', $data['entity_test_mulrev_property_revision']['table']['base']['title']);
333 $this->assertEquals('revision_id', $data['entity_test_mulrev_property_revision']['table']['base']['field']);
334 $this->assertFalse(isset($data['entity_test_mulrev_revision']['table']['base']));
336 $this->assertEquals('entity_test_mulrev', $data['entity_test_mulrev_property_revision']['table']['entity type']);
337 $this->assertEquals('Entity test revision', $data['entity_test_mulrev_revision']['table']['group']);
338 $this->assertEquals('entity_test', $data['entity_test']['table']['provider']);
340 // Ensure the join information is set up properly.
341 // Tests the join definition between the base and the revision table.
342 $revision_field_data = $data['entity_test_mulrev_property_revision'];
343 $this->assertCount(1, $revision_field_data['table']['join']);
344 $this->assertEquals([
345 'entity_test_mulrev_field_data' => [
346 'left_field' => 'revision_id',
347 'field' => 'revision_id',
350 ], $revision_field_data['table']['join']);
352 $revision_base_data = $data['entity_test_mulrev_revision'];
353 $this->assertCount(1, $revision_base_data['table']['join']);
354 $this->assertEquals([
355 'entity_test_mulrev_property_revision' => [
356 'left_field' => 'revision_id',
357 'field' => 'revision_id',
360 ], $revision_base_data['table']['join']);
361 $this->assertFalse(isset($data['data_table']));
365 * Helper method to mock all store definitions.
367 protected function setupFieldStorageDefinition() {
368 $id_field_storage_definition = $this->getMock('Drupal\Core\Field\FieldStorageDefinitionInterface');
369 $id_field_storage_definition->expects($this->any())
370 ->method('getSchema')
371 ->willReturn(IntegerItem::schema($id_field_storage_definition));
372 $uuid_field_storage_definition = $this->getMock('Drupal\Core\Field\FieldStorageDefinitionInterface');
373 $uuid_field_storage_definition->expects($this->any())
374 ->method('getSchema')
375 ->willReturn(UuidItem::schema($uuid_field_storage_definition));
376 $type_field_storage_definition = $this->getMock('Drupal\Core\Field\FieldStorageDefinitionInterface');
377 $type_field_storage_definition->expects($this->any())
378 ->method('getSchema')
379 ->willReturn(StringItem::schema($type_field_storage_definition));
380 $langcode_field_storage_definition = $this->getMock('Drupal\Core\Field\FieldStorageDefinitionInterface');
381 $langcode_field_storage_definition->expects($this->any())
382 ->method('getSchema')
383 ->willReturn(LanguageItem::schema($langcode_field_storage_definition));
384 $name_field_storage_definition = $this->getMock('Drupal\Core\Field\FieldStorageDefinitionInterface');
385 $name_field_storage_definition->expects($this->any())
386 ->method('getSchema')
387 ->willReturn(StringItem::schema($name_field_storage_definition));
388 $description_field_storage_definition = $this->getMock('Drupal\Core\Field\FieldStorageDefinitionInterface');
389 $description_field_storage_definition->expects($this->any())
390 ->method('getSchema')
391 ->willReturn(TextLongItem::schema($description_field_storage_definition));
392 $homepage_field_storage_definition = $this->getMock('Drupal\Core\Field\FieldStorageDefinitionInterface');
393 $homepage_field_storage_definition->expects($this->any())
394 ->method('getSchema')
395 ->willReturn(UriItem::schema($homepage_field_storage_definition));
396 $string_field_storage_definition = $this->getMock('Drupal\Core\Field\FieldStorageDefinitionInterface');
397 $string_field_storage_definition->expects($this->any())
398 ->method('getSchema')
399 ->willReturn(StringItem::schema($string_field_storage_definition));
401 // Setup the user_id entity reference field.
402 $this->entityManager->expects($this->any())
403 ->method('getDefinition')
405 ['user', TRUE, static::userEntityInfo()],
408 $user_id_field_storage_definition = $this->getMock('Drupal\Core\Field\FieldStorageDefinitionInterface');
409 $user_id_field_storage_definition->expects($this->any())
410 ->method('getSetting')
411 ->with('target_type')
412 ->willReturn('user');
413 $user_id_field_storage_definition->expects($this->any())
414 ->method('getSettings')
415 ->willReturn(['target_type' => 'user']);
416 $user_id_field_storage_definition->expects($this->any())
417 ->method('getSchema')
418 ->willReturn(EntityReferenceItem::schema($user_id_field_storage_definition));
420 $revision_id_field_storage_definition = $this->getMock('Drupal\Core\Field\FieldStorageDefinitionInterface');
421 $revision_id_field_storage_definition->expects($this->any())
422 ->method('getSchema')
423 ->willReturn(IntegerItem::schema($revision_id_field_storage_definition));
425 $this->entityManager->expects($this->any())
426 ->method('getFieldStorageDefinitions')
428 'id' => $id_field_storage_definition,
429 'uuid' => $uuid_field_storage_definition,
430 'type' => $type_field_storage_definition,
431 'langcode' => $langcode_field_storage_definition,
432 'name' => $name_field_storage_definition,
433 'description' => $description_field_storage_definition,
434 'homepage' => $homepage_field_storage_definition,
435 'string' => $string_field_storage_definition,
436 'user_id' => $user_id_field_storage_definition,
437 'revision_id' => $revision_id_field_storage_definition,
442 * Tests fields on the base table.
444 public function testBaseTableFields() {
445 $base_field_definitions = $this->setupBaseFields(EntityTest::baseFieldDefinitions($this->baseEntityType));
446 $user_base_field_definitions = [
447 'uid' => BaseFieldDefinition::create('integer')
449 ->setDescription('The ID of the user entity.')
451 ->setSetting('unsigned', TRUE)
453 $this->entityManager->expects($this->any())
454 ->method('getBaseFieldDefinitions')
455 ->will($this->returnValueMap([
456 ['user', $user_base_field_definitions],
457 ['entity_test', $base_field_definitions],
459 // Setup the table mapping.
460 $table_mapping = $this->getMockBuilder(DefaultTableMapping::class)
461 ->disableOriginalConstructor()
463 $table_mapping->expects($this->any())
464 ->method('getTableNames')
465 ->willReturn(['entity_test', 'entity_test__string']);
466 $table_mapping->expects($this->any())
467 ->method('getColumnNames')
469 ['id', ['value' => 'id']],
470 ['uuid', ['value' => 'uuid']],
471 ['type', ['value' => 'type']],
472 ['langcode', ['value' => 'langcode']],
473 ['name', ['value' => 'name']],
474 ['description', ['value' => 'description__value', 'format' => 'description__format']],
475 ['homepage', ['value' => 'homepage']],
476 ['user_id', ['target_id' => 'user_id']],
477 ['string', ['value' => 'value']],
479 $table_mapping->expects($this->any())
480 ->method('getFieldNames')
482 ['entity_test', ['id', 'uuid', 'type', 'langcode', 'name', 'description', 'homepage', 'user_id']],
483 ['entity_test__string', ['string']],
485 $table_mapping->expects($this->any())
486 ->method('requiresDedicatedTableStorage')
487 ->willReturnCallback(function (BaseFieldDefinition $base_field) {
488 return $base_field->getName() === 'string';
490 $table_mapping->expects($this->any())
491 ->method('getDedicatedDataTableName')
492 ->willReturnCallback(function (BaseFieldDefinition $base_field) {
493 if ($base_field->getName() === 'string') {
494 return 'entity_test__string';
498 $this->entityStorage->expects($this->once())
499 ->method('getTableMapping')
500 ->willReturn($table_mapping);
502 $this->setupFieldStorageDefinition();
504 $data = $this->viewsData->getViewsData();
506 $this->assertNumericField($data['entity_test']['id']);
507 $this->assertField($data['entity_test']['id'], 'id');
508 $this->assertUuidField($data['entity_test']['uuid']);
509 $this->assertField($data['entity_test']['uuid'], 'uuid');
510 $this->assertStringField($data['entity_test']['type']);
511 $this->assertEquals('type', $data['entity_test']['type']['entity field']);
513 $this->assertLanguageField($data['entity_test']['langcode']);
514 $this->assertField($data['entity_test']['langcode'], 'langcode');
515 $this->assertEquals('Original language', $data['entity_test']['langcode']['title']);
517 $this->assertStringField($data['entity_test']['name']);
518 $this->assertField($data['entity_test']['name'], 'name');
520 $this->assertLongTextField($data['entity_test'], 'description');
521 $this->assertField($data['entity_test']['description__value'], 'description');
522 $this->assertField($data['entity_test']['description__format'], 'description');
524 $this->assertUriField($data['entity_test']['homepage']);
525 $this->assertField($data['entity_test']['homepage'], 'homepage');
527 $this->assertEntityReferenceField($data['entity_test']['user_id']);
528 $this->assertField($data['entity_test']['user_id'], 'user_id');
530 $relationship = $data['entity_test']['user_id']['relationship'];
531 $this->assertEquals('users_field_data', $relationship['base']);
532 $this->assertEquals('uid', $relationship['base field']);
534 $this->assertStringField($data['entity_test__string']['string']);
535 $this->assertField($data['entity_test__string']['string'], 'string');
536 $this->assertEquals([
537 'left_field' => 'id',
538 'field' => 'entity_id',
540 'field' => 'deleted',
545 ], $data['entity_test__string']['table']['join']['entity_test']);
549 * Tests fields on the data table.
551 public function testDataTableFields() {
552 $entity_type = $this->baseEntityType
553 ->set('data_table', 'entity_test_mul_property_data')
554 ->set('base_table', 'entity_test_mul')
555 ->set('id', 'entity_test_mul')
556 ->setKey('bundle', 'type');
557 $base_field_definitions = $this->setupBaseFields(EntityTestMul::baseFieldDefinitions($this->baseEntityType));
558 $base_field_definitions['type'] = BaseFieldDefinition::create('entity_reference')
559 ->setLabel('entity test type')
560 ->setSetting('target_type', 'entity_test_bundle')
561 ->setTranslatable(TRUE);
562 $base_field_definitions = $this->setupBaseFields($base_field_definitions);
563 $user_base_field_definitions = [
564 'uid' => BaseFieldDefinition::create('integer')
566 ->setDescription('The ID of the user entity.')
568 ->setSetting('unsigned', TRUE)
570 $entity_test_type = new ConfigEntityType(['id' => 'entity_test_bundle']);
572 $this->entityManager->expects($this->any())
573 ->method('getBaseFieldDefinitions')
574 ->will($this->returnValueMap([
575 ['user', $user_base_field_definitions],
576 ['entity_test_mul', $base_field_definitions],
579 $this->viewsData->setEntityType($entity_type);
581 // Setup the table mapping.
582 $table_mapping = $this->getMockBuilder(DefaultTableMapping::class)
583 ->disableOriginalConstructor()
585 $table_mapping->expects($this->any())
586 ->method('getTableNames')
587 ->willReturn(['entity_test_mul', 'entity_test_mul_property_data', 'entity_test_mul__string']);
588 $table_mapping->expects($this->any())
589 ->method('getColumnNames')
591 ['id', ['value' => 'id']],
592 ['uuid', ['value' => 'uuid']],
593 ['type', ['value' => 'type']],
594 ['langcode', ['value' => 'langcode']],
595 ['name', ['value' => 'name']],
596 ['description', ['value' => 'description__value', 'format' => 'description__format']],
597 ['homepage', ['value' => 'homepage']],
598 ['user_id', ['target_id' => 'user_id']],
599 ['string', ['value' => 'value']],
601 $table_mapping->expects($this->any())
602 ->method('getFieldNames')
604 ['entity_test_mul', ['uuid']],
605 ['entity_test_mul_property_data', ['id', 'type', 'langcode', 'name', 'description', 'homepage', 'user_id']],
606 ['entity_test_mul__string', ['string']],
609 $table_mapping->expects($this->any())
610 ->method('getFieldTableName')
611 ->willReturnCallback(function ($field) {
612 if ($field == 'uuid') {
613 return 'entity_test_mul';
615 return 'entity_test_mul_property_data';
617 $table_mapping->expects($this->any())
618 ->method('requiresDedicatedTableStorage')
619 ->willReturnCallback(function (BaseFieldDefinition $base_field) {
620 return $base_field->getName() === 'string';
622 $table_mapping->expects($this->any())
623 ->method('getDedicatedDataTableName')
624 ->willReturnCallback(function (BaseFieldDefinition $base_field) {
625 if ($base_field->getName() === 'string') {
626 return 'entity_test_mul__string';
630 $this->entityStorage->expects($this->once())
631 ->method('getTableMapping')
632 ->willReturn($table_mapping);
634 $this->setupFieldStorageDefinition();
636 $user_entity_type = static::userEntityInfo();
637 $this->entityManager->expects($this->any())
638 ->method('getDefinition')
639 ->will($this->returnValueMap([
640 ['user', TRUE, $user_entity_type],
641 ['entity_test_bundle', TRUE, $entity_test_type],
644 $data = $this->viewsData->getViewsData();
646 // Check the base fields.
647 $this->assertFalse(isset($data['entity_test_mul']['id']));
648 $this->assertFalse(isset($data['entity_test_mul']['type']));
649 $this->assertUuidField($data['entity_test_mul']['uuid']);
650 $this->assertField($data['entity_test_mul']['uuid'], 'uuid');
652 $this->assertFalse(isset($data['entity_test_mul']['type']['relationship']));
654 // Also ensure that field_data only fields don't appear on the base table.
655 $this->assertFalse(isset($data['entity_test_mul']['name']));
656 $this->assertFalse(isset($data['entity_test_mul']['description']));
657 $this->assertFalse(isset($data['entity_test_mul']['description__value']));
658 $this->assertFalse(isset($data['entity_test_mul']['description__format']));
659 $this->assertFalse(isset($data['entity_test_mul']['user_id']));
660 $this->assertFalse(isset($data['entity_test_mul']['homepage']));
662 // Check the data fields.
663 $this->assertNumericField($data['entity_test_mul_property_data']['id']);
664 $this->assertField($data['entity_test_mul_property_data']['id'], 'id');
666 $this->assertBundleField($data['entity_test_mul_property_data']['type']);
667 $this->assertField($data['entity_test_mul_property_data']['type'], 'type');
669 $this->assertLanguageField($data['entity_test_mul_property_data']['langcode']);
670 $this->assertField($data['entity_test_mul_property_data']['langcode'], 'langcode');
671 $this->assertEquals('Translation language', $data['entity_test_mul_property_data']['langcode']['title']);
673 $this->assertStringField($data['entity_test_mul_property_data']['name']);
674 $this->assertField($data['entity_test_mul_property_data']['name'], 'name');
676 $this->assertLongTextField($data['entity_test_mul_property_data'], 'description');
677 $this->assertField($data['entity_test_mul_property_data']['description__value'], 'description');
678 $this->assertField($data['entity_test_mul_property_data']['description__format'], 'description');
680 $this->assertUriField($data['entity_test_mul_property_data']['homepage']);
681 $this->assertField($data['entity_test_mul_property_data']['homepage'], 'homepage');
683 $this->assertEntityReferenceField($data['entity_test_mul_property_data']['user_id']);
684 $this->assertField($data['entity_test_mul_property_data']['user_id'], 'user_id');
685 $relationship = $data['entity_test_mul_property_data']['user_id']['relationship'];
686 $this->assertEquals('users_field_data', $relationship['base']);
687 $this->assertEquals('uid', $relationship['base field']);
689 $this->assertStringField($data['entity_test_mul__string']['string']);
690 $this->assertField($data['entity_test_mul__string']['string'], 'string');
691 $this->assertEquals([
692 'left_field' => 'id',
693 'field' => 'entity_id',
695 'field' => 'deleted',
700 ], $data['entity_test_mul__string']['table']['join']['entity_test_mul']);
704 * Tests fields on the revision table.
706 public function testRevisionTableFields() {
707 $entity_type = $this->baseEntityType
708 ->set('base_table', 'entity_test_mulrev')
709 ->set('revision_table', 'entity_test_mulrev_revision')
710 ->set('data_table', 'entity_test_mulrev_property_data')
711 ->set('revision_data_table', 'entity_test_mulrev_property_revision')
712 ->set('id', 'entity_test_mulrev')
713 ->set('translatable', TRUE);
714 $base_field_definitions = $this->setupBaseFields(EntityTestMulRev::baseFieldDefinitions($this->baseEntityType));
715 $user_base_field_definitions = [
716 'uid' => BaseFieldDefinition::create('integer')
718 ->setDescription('The ID of the user entity.')
720 ->setSetting('unsigned', TRUE)
722 $this->entityManager->expects($this->any())
723 ->method('getBaseFieldDefinitions')
724 ->will($this->returnValueMap([
725 ['user', $user_base_field_definitions],
726 ['entity_test_mulrev', $base_field_definitions],
729 $this->viewsData->setEntityType($entity_type);
731 // Setup the table mapping.
732 $table_mapping = $this->getMockBuilder(DefaultTableMapping::class)
733 ->disableOriginalConstructor()
735 $table_mapping->expects($this->any())
736 ->method('getTableNames')
737 ->willReturn(['entity_test_mulrev', 'entity_test_mulrev_revision', 'entity_test_mulrev_property_data', 'entity_test_mulrev_property_revision', 'entity_test_mulrev__string', 'entity_test_mulrev_revision__string']);
738 $table_mapping->expects($this->any())
739 ->method('getColumnNames')
741 ['id', ['value' => 'id']],
742 ['uuid', ['value' => 'uuid']],
743 ['type', ['value' => 'type']],
744 ['langcode', ['value' => 'langcode']],
745 ['name', ['value' => 'name']],
746 ['description', ['value' => 'description__value', 'format' => 'description__format']],
747 ['homepage', ['value' => 'homepage']],
748 ['user_id', ['target_id' => 'user_id']],
749 ['revision_id', ['value' => 'id']],
750 ['string', ['value' => 'value']],
752 $table_mapping->expects($this->any())
753 ->method('getFieldNames')
755 ['entity_test_mulrev', ['id', 'revision_id', 'uuid', 'type']],
756 ['entity_test_mulrev_revision', ['id', 'revision_id', 'langcode']],
757 ['entity_test_mulrev_property_data', ['id', 'revision_id', 'langcode', 'name', 'description', 'homepage', 'user_id']],
758 ['entity_test_mulrev_property_revision', ['id', 'revision_id', 'langcode', 'name', 'description', 'homepage', 'user_id']],
759 ['entity_test_mulrev__string', ['string']],
760 ['entity_test_mulrev_revision__string', ['string']],
762 $table_mapping->expects($this->any())
763 ->method('requiresDedicatedTableStorage')
764 ->willReturnCallback(function (BaseFieldDefinition $base_field) {
765 return $base_field->getName() === 'string';
767 $table_mapping->expects($this->any())
768 ->method('getDedicatedDataTableName')
769 ->willReturnCallback(function (BaseFieldDefinition $base_field) {
770 if ($base_field->getName() === 'string') {
771 return 'entity_test_mulrev__string';
775 $table_mapping->expects($this->any())
776 ->method('getDedicatedRevisionTableName')
777 ->willReturnCallback(function (BaseFieldDefinition $base_field) {
778 if ($base_field->getName() === 'string') {
779 return 'entity_test_mulrev_revision__string';
783 $table_mapping->expects($this->any())
784 ->method('getFieldTableName')
785 ->willReturnCallback(function ($field) {
786 if ($field == 'uuid') {
787 return 'entity_test_mulrev';
789 return 'entity_test_mulrev_property_data';
792 $this->entityStorage->expects($this->once())
793 ->method('getTableMapping')
794 ->willReturn($table_mapping);
796 $this->setupFieldStorageDefinition();
798 $data = $this->viewsData->getViewsData();
800 // Check the base fields.
801 $this->assertFalse(isset($data['entity_test_mulrev']['id']));
802 $this->assertFalse(isset($data['entity_test_mulrev']['type']));
803 $this->assertFalse(isset($data['entity_test_mulrev']['revision_id']));
804 $this->assertUuidField($data['entity_test_mulrev']['uuid']);
805 $this->assertField($data['entity_test_mulrev']['uuid'], 'uuid');
807 // Also ensure that field_data only fields don't appear on the base table.
808 $this->assertFalse(isset($data['entity_test_mulrev']['name']));
809 $this->assertFalse(isset($data['entity_test_mul']['description']));
810 $this->assertFalse(isset($data['entity_test_mul']['description__value']));
811 $this->assertFalse(isset($data['entity_test_mul']['description__format']));
812 $this->assertFalse(isset($data['entity_test_mul']['homepage']));
813 $this->assertFalse(isset($data['entity_test_mulrev']['langcode']));
814 $this->assertFalse(isset($data['entity_test_mulrev']['user_id']));
816 // Check the revision fields. The revision ID should only appear in the data
818 $this->assertFalse(isset($data['entity_test_mulrev_revision']['revision_id']));
820 // Also ensure that field_data only fields don't appear on the revision table.
821 $this->assertFalse(isset($data['entity_test_mulrev_revision']['id']));
822 $this->assertFalse(isset($data['entity_test_mulrev_revision']['name']));
823 $this->assertFalse(isset($data['entity_test_mulrev_revision']['description']));
824 $this->assertFalse(isset($data['entity_test_mulrev_revision']['description__value']));
825 $this->assertFalse(isset($data['entity_test_mulrev_revision']['description__format']));
826 $this->assertFalse(isset($data['entity_test_mulrev_revision']['homepage']));
827 $this->assertFalse(isset($data['entity_test_mulrev_revision']['user_id']));
829 // Check the data fields.
830 $this->assertNumericField($data['entity_test_mulrev_property_data']['id']);
831 $this->assertField($data['entity_test_mulrev_property_data']['id'], 'id');
832 $this->assertNumericField($data['entity_test_mulrev_property_data']['revision_id']);
833 $this->assertField($data['entity_test_mulrev_property_data']['revision_id'], 'revision_id');
834 $this->assertLanguageField($data['entity_test_mulrev_property_data']['langcode']);
835 $this->assertField($data['entity_test_mulrev_property_data']['langcode'], 'langcode');
836 $this->assertStringField($data['entity_test_mulrev_property_data']['name']);
837 $this->assertField($data['entity_test_mulrev_property_data']['name'], 'name');
839 $this->assertLongTextField($data['entity_test_mulrev_property_data'], 'description');
840 $this->assertField($data['entity_test_mulrev_property_data']['description__value'], 'description');
841 $this->assertField($data['entity_test_mulrev_property_data']['description__format'], 'description');
842 $this->assertUriField($data['entity_test_mulrev_property_data']['homepage']);
843 $this->assertField($data['entity_test_mulrev_property_data']['homepage'], 'homepage');
845 $this->assertEntityReferenceField($data['entity_test_mulrev_property_data']['user_id']);
846 $this->assertField($data['entity_test_mulrev_property_data']['user_id'], 'user_id');
847 $relationship = $data['entity_test_mulrev_property_data']['user_id']['relationship'];
848 $this->assertEquals('users_field_data', $relationship['base']);
849 $this->assertEquals('uid', $relationship['base field']);
851 // Check the property data fields.
852 $this->assertNumericField($data['entity_test_mulrev_property_revision']['id']);
853 $this->assertField($data['entity_test_mulrev_property_revision']['id'], 'id');
855 $this->assertLanguageField($data['entity_test_mulrev_property_revision']['langcode']);
856 $this->assertField($data['entity_test_mulrev_property_revision']['langcode'], 'langcode');
857 $this->assertEquals('Translation language', $data['entity_test_mulrev_property_revision']['langcode']['title']);
859 $this->assertStringField($data['entity_test_mulrev_property_revision']['name']);
860 $this->assertField($data['entity_test_mulrev_property_revision']['name'], 'name');
862 $this->assertLongTextField($data['entity_test_mulrev_property_revision'], 'description');
863 $this->assertField($data['entity_test_mulrev_property_revision']['description__value'], 'description');
864 $this->assertField($data['entity_test_mulrev_property_revision']['description__format'], 'description');
866 $this->assertUriField($data['entity_test_mulrev_property_revision']['homepage']);
867 $this->assertField($data['entity_test_mulrev_property_revision']['homepage'], 'homepage');
869 $this->assertEntityReferenceField($data['entity_test_mulrev_property_revision']['user_id']);
870 $this->assertField($data['entity_test_mulrev_property_revision']['user_id'], 'user_id');
871 $relationship = $data['entity_test_mulrev_property_revision']['user_id']['relationship'];
872 $this->assertEquals('users_field_data', $relationship['base']);
873 $this->assertEquals('uid', $relationship['base field']);
875 $this->assertStringField($data['entity_test_mulrev__string']['string']);
876 $this->assertField($data['entity_test_mulrev__string']['string'], 'string');
877 $this->assertEquals([
878 'left_field' => 'id',
879 'field' => 'entity_id',
881 'field' => 'deleted',
886 ], $data['entity_test_mulrev__string']['table']['join']['entity_test_mulrev_property_data']);
888 $this->assertStringField($data['entity_test_mulrev_revision__string']['string']);
889 $this->assertField($data['entity_test_mulrev_revision__string']['string'], 'string');
890 $this->assertEquals([
891 'left_field' => 'revision_id',
892 'field' => 'entity_id',
894 'field' => 'deleted',
899 ], $data['entity_test_mulrev_revision__string']['table']['join']['entity_test_mulrev_property_revision']);
903 * Tests generic stuff per field.
906 * The views data to check.
907 * @param string $field_name
908 * The entity field name.
910 protected function assertField($data, $field_name) {
911 $this->assertEquals($field_name, $data['entity field']);
915 * Tests add link types.
917 public function testEntityLinks() {
918 $this->baseEntityType->setLinkTemplate('canonical', '/entity_test/{entity_test}');
919 $this->baseEntityType->setLinkTemplate('edit-form', '/entity_test/{entity_test}/edit');
920 $this->baseEntityType->setLinkTemplate('delete-form', '/entity_test/{entity_test}/delete');
922 $data = $this->viewsData->getViewsData();
923 $this->assertEquals('entity_link', $data['entity_test']['view_entity_test']['field']['id']);
924 $this->assertEquals('entity_link_edit', $data['entity_test']['edit_entity_test']['field']['id']);
925 $this->assertEquals('entity_link_delete', $data['entity_test']['delete_entity_test']['field']['id']);
929 * Tests additional edit links.
931 public function testEntityLinksJustEditForm() {
932 $this->baseEntityType->setLinkTemplate('edit-form', '/entity_test/{entity_test}/edit');
934 $data = $this->viewsData->getViewsData();
935 $this->assertFalse(isset($data['entity_test']['view_entity_test']));
936 $this->assertFalse(isset($data['entity_test']['delete_entity_test']));
938 $this->assertEquals('entity_link_edit', $data['entity_test']['edit_entity_test']['field']['id']);
942 * @covers ::getViewsData
944 public function testGetViewsDataWithoutEntityOperations() {
945 // Make sure there is no list builder. The API does not document is
946 // supports resetting entity handlers, so this might break in the future.
947 $this->baseEntityType->setListBuilderClass(NULL);
948 $data = $this->viewsData->getViewsData();
949 $this->assertArrayNotHasKey('operations', $data[$this->baseEntityType->getBaseTable()]);
953 * @covers ::getViewsData
955 public function testGetViewsDataWithEntityOperations() {
956 $this->baseEntityType->setListBuilderClass('\Drupal\Core\Entity\EntityListBuilder');
957 $data = $this->viewsData->getViewsData();
958 $this->assertSame('entity_operations', $data[$this->baseEntityType->getBaseTable()]['operations']['field']['id']);
962 * Tests views data for a string field.
965 * The views data to check.
967 protected function assertStringField($data) {
968 $this->assertEquals('field', $data['field']['id']);
969 $this->assertEquals('string', $data['filter']['id']);
970 $this->assertEquals('string', $data['argument']['id']);
971 $this->assertEquals('standard', $data['sort']['id']);
975 * Tests views data for a URI field.
978 * The views data to check.
980 protected function assertUriField($data) {
981 $this->assertEquals('field', $data['field']['id']);
982 $this->assertEquals('string', $data['field']['default_formatter']);
983 $this->assertEquals('string', $data['filter']['id']);
984 $this->assertEquals('string', $data['argument']['id']);
985 $this->assertEquals('standard', $data['sort']['id']);
989 * Tests views data for a long text field.
992 * The views data for the table this field is in.
994 * The name of the field being checked.
996 protected function assertLongTextField($data, $field_name) {
997 $value_field = $data[$field_name . '__value'];
998 $this->assertEquals('field', $value_field['field']['id']);
999 $this->assertEquals($field_name . '__format', $value_field['field']['format']);
1000 $this->assertEquals('string', $value_field['filter']['id']);
1001 $this->assertEquals('string', $value_field['argument']['id']);
1002 $this->assertEquals('standard', $value_field['sort']['id']);
1004 $this->assertStringField($data[$field_name . '__format']);
1008 * Tests views data for a UUID field.
1010 * @param array $data
1011 * The views data to check.
1013 protected function assertUuidField($data) {
1014 // @todo Can we provide additional support for UUIDs in views?
1015 $this->assertEquals('field', $data['field']['id']);
1016 $this->assertFalse($data['field']['click sortable']);
1017 $this->assertEquals('string', $data['filter']['id']);
1018 $this->assertEquals('string', $data['argument']['id']);
1019 $this->assertEquals('standard', $data['sort']['id']);
1023 * Tests views data for a numeric field.
1025 * @param array $data
1026 * The views data to check.
1028 protected function assertNumericField($data) {
1029 $this->assertEquals('field', $data['field']['id']);
1030 $this->assertEquals('numeric', $data['filter']['id']);
1031 $this->assertEquals('numeric', $data['argument']['id']);
1032 $this->assertEquals('standard', $data['sort']['id']);
1036 * Tests views data for a language field.
1038 * @param array $data
1039 * The views data to check.
1041 protected function assertLanguageField($data) {
1042 $this->assertEquals('field', $data['field']['id']);
1043 $this->assertEquals('language', $data['filter']['id']);
1044 $this->assertEquals('language', $data['argument']['id']);
1045 $this->assertEquals('standard', $data['sort']['id']);
1049 * Tests views data for a entity reference field.
1051 protected function assertEntityReferenceField($data) {
1052 $this->assertEquals('field', $data['field']['id']);
1053 $this->assertEquals('numeric', $data['filter']['id']);
1054 $this->assertEquals('numeric', $data['argument']['id']);
1055 $this->assertEquals('standard', $data['sort']['id']);
1059 * Tests views data for a bundle field.
1061 protected function assertBundleField($data) {
1062 $this->assertEquals('field', $data['field']['id']);
1063 $this->assertEquals('bundle', $data['filter']['id']);
1064 $this->assertEquals('string', $data['argument']['id']);
1065 $this->assertEquals('standard', $data['sort']['id']);
1069 * Returns entity info for the user entity.
1073 protected static function userEntityInfo() {
1074 return new ContentEntityType([
1076 'class' => 'Drupal\user\Entity\User',
1078 'base_table' => 'users',
1079 'data_table' => 'users_field_data',
1089 class TestEntityViewsData extends EntityViewsData {
1091 public function setEntityType(EntityTypeInterface $entity_type) {
1092 $this->entityType = $entity_type;
1097 class TestEntityType extends ContentEntityType {
1100 * Sets a specific entity key.
1102 * @param string $key
1103 * The name of the entity key.
1104 * @param string $value
1105 * The new value of the key.
1109 public function setKey($key, $value) {
1110 $this->entity_keys[$key] = $value;
1116 namespace Drupal\entity_test\Entity;
1118 if (!function_exists('t')) {
1119 function t($string, array $args = []) {
1120 return strtr($string, $args);
1125 namespace Drupal\Core\Entity;
1127 if (!function_exists('t')) {
1128 function t($string, array $args = []) {
1129 return strtr($string, $args);