TypedDataDefinitionTest.php

<?php

declare (strict_types=1);
namespace Drupal\KernelTests\Core\TypedData;

use Drupal\Core\TypedData\ComplexDataDefinitionInterface;
use Drupal\Core\TypedData\DataDefinition;
use Drupal\Core\TypedData\DataDefinitionInterface;
use Drupal\Core\TypedData\DataReferenceDefinition;
use Drupal\Core\TypedData\DataReferenceDefinitionInterface;
use Drupal\Core\TypedData\DataReferenceInterface;
use Drupal\Core\TypedData\ListDataDefinition;
use Drupal\Core\TypedData\ListDataDefinitionInterface;
use Drupal\Core\TypedData\MapDataDefinition;
use Drupal\KernelTests\KernelTestBase;

/**
 * Tests deriving metadata of core data types.
 *
 * @group TypedData
 */
class TypedDataDefinitionTest extends KernelTestBase {
  
  /**
   * The typed data manager to use.
   *
   * @var \Drupal\Core\TypedData\TypedDataManager
   */
  protected $typedDataManager;
  
  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    parent::setUp();
    $this->typedDataManager = $this->container
      ->get('typed_data_manager');
  }
  
  /**
   * Tests deriving metadata about list items.
   */
  public function testLists() : void {
    $list_definition = ListDataDefinition::create('string');
    $this->assertInstanceOf(ListDataDefinitionInterface::class, $list_definition);
    $item_definition = $list_definition->getItemDefinition();
    $this->assertInstanceOf(DataDefinitionInterface::class, $item_definition);
    $this->assertEquals('string', $item_definition->getDataType());
    // Test using the definition factory.
    $list_definition2 = $this->typedDataManager
      ->createListDataDefinition('string');
    $this->assertInstanceOf(ListDataDefinitionInterface::class, $list_definition2);
    $this->assertEquals($list_definition, $list_definition2);
    // Test creating the definition of data with type 'list', which is the same
    // as creating a definition of a list of items of type 'any'.
    $list_definition = $this->typedDataManager
      ->createDataDefinition('list');
    $this->assertInstanceOf(ListDataDefinitionInterface::class, $list_definition);
    $this->assertEquals('list', $list_definition->getDataType());
    $this->assertEquals('any', $list_definition->getItemDefinition()
      ->getDataType());
  }
  
  /**
   * Tests deriving metadata about maps.
   */
  public function testMaps() : void {
    $map_definition = MapDataDefinition::create()->setPropertyDefinition('one', DataDefinition::create('string'))
      ->setPropertyDefinition('two', DataDefinition::create('string'))
      ->setPropertyDefinition('three', DataDefinition::create('string'));
    $this->assertInstanceOf(ComplexDataDefinitionInterface::class, $map_definition);
    // Test retrieving metadata about contained properties.
    $this->assertEquals([
      'one',
      'two',
      'three',
    ], array_keys($map_definition->getPropertyDefinitions()));
    $this->assertEquals('string', $map_definition->getPropertyDefinition('one')
      ->getDataType());
    $this->assertNull($map_definition->getMainPropertyName());
    $this->assertNull($map_definition->getPropertyDefinition('invalid'));
    // Test using the definition factory.
    $map_definition2 = $this->typedDataManager
      ->createDataDefinition('map');
    $this->assertInstanceOf(ComplexDataDefinitionInterface::class, $map_definition2);
    $map_definition2->setPropertyDefinition('one', DataDefinition::create('string'))
      ->setPropertyDefinition('two', DataDefinition::create('string'))
      ->setPropertyDefinition('three', DataDefinition::create('string'));
    $this->assertEquals(serialize($map_definition2), serialize($map_definition));
  }
  
  /**
   * Tests deriving metadata from data references.
   */
  public function testDataReferences() : void {
    $language_reference_definition = DataReferenceDefinition::create('language');
    $this->assertInstanceOf(DataReferenceDefinitionInterface::class, $language_reference_definition);
    // Test retrieving metadata about the referenced data.
    $this->assertEquals('language', $language_reference_definition->getTargetDefinition()
      ->getDataType());
    // Test using the definition factory.
    $language_reference_definition2 = $this->typedDataManager
      ->createDataDefinition('language_reference');
    $this->assertInstanceOf(DataReferenceDefinitionInterface::class, $language_reference_definition2);
    $this->assertEquals(serialize($language_reference_definition2), serialize($language_reference_definition));
  }
  
  /**
   * Tests getString() throws exception when getType() is not implemented.
   */
  public function testNotImplementedGetType() : void {
    $language_reference_definition = DataReferenceDefinition::create('language');
    $language_reference = $this->typedDataManager
      ->create($language_reference_definition);
    $this->assertInstanceOf(DataReferenceInterface::class, $language_reference);
    $this->expectException(\BadMethodCallException::class);
    $this->expectExceptionMessageMatches('/getType\\(\\) not implemented/');
    $language_reference->getString();
  }

}