www.aleph1.co.uk Git - yaffs-website/blob - web/core/tests/Drupal/Tests/Core/Entity/BaseFieldDefinitionTest.php

   1 <?php
   2
   3 namespace Drupal\Tests\Core\Entity;
   4
   5 use Drupal\Core\DependencyInjection\ContainerBuilder;
   6 use Drupal\Core\Field\BaseFieldDefinition;
   7 use Drupal\Core\Field\FieldStorageDefinitionInterface;
   8 use Drupal\Tests\UnitTestCase;
   9
  10 /**
  11  * Unit test for BaseFieldDefinition.
  12  *
  13  * @group Entity
  14  * @coversDefaultClass \Drupal\Core\Field\BaseFieldDefinition
  15  */
  16 class BaseFieldDefinitionTest extends UnitTestCase {
  17
  18   /**
  19    * A dummy field type name.
  20    *
  21    * @var string
  22    */
  23   protected $fieldType;
  24
  25   /**
  26    * A dummy field type definition.
  27    *
  28    * @var string
  29    */
  30   protected $fieldTypeDefinition;
  31
  32
  33   /**
  34    * {@inheritdoc}
  35    */
  36   protected function setUp() {
  37     // Mock the field type manager and place it in the container.
  38     $field_type_manager = $this->getMock('Drupal\Core\Field\FieldTypePluginManagerInterface');
  39
  40     $this->fieldType = $this->randomMachineName();
  41     $this->fieldTypeDefinition = [
  42       'id' => $this->fieldType,
  43       'storage_settings' => [
  44         'some_setting' => 'value 1'
  45       ],
  46       'field_settings' => [
  47         'some_instance_setting' => 'value 2',
  48       ],
  49     ];
  50
  51     $field_type_manager->expects($this->any())
  52       ->method('getDefinitions')
  53       ->will($this->returnValue([$this->fieldType => $this->fieldTypeDefinition]));
  54     $field_type_manager->expects($this->any())
  55       ->method('getDefinition')
  56       ->with($this->fieldType)
  57       ->will($this->returnValue($this->fieldTypeDefinition));
  58     $field_type_manager->expects($this->any())
  59       ->method('getDefaultStorageSettings')
  60       ->with($this->fieldType)
  61       ->will($this->returnValue($this->fieldTypeDefinition['storage_settings']));
  62     $field_type_manager->expects($this->any())
  63       ->method('getDefaultFieldSettings')
  64       ->with($this->fieldType)
  65       ->will($this->returnValue($this->fieldTypeDefinition['field_settings']));
  66
  67     $container = new ContainerBuilder();
  68     $container->set('plugin.manager.field.field_type', $field_type_manager);
  69     \Drupal::setContainer($container);
  70   }
  71
  72   /**
  73    * Tests field name methods.
  74    *
  75    * @covers ::getName
  76    */
  77   public function testFieldName() {
  78     $definition = BaseFieldDefinition::create($this->fieldType);
  79     $field_name = $this->randomMachineName();
  80     $definition->setName($field_name);
  81     $this->assertEquals($field_name, $definition->getName());
  82   }
  83
  84   /**
  85    * Tests field label methods.
  86    *
  87    * @covers ::getLabel
  88    */
  89   public function testFieldLabel() {
  90     $definition = BaseFieldDefinition::create($this->fieldType);
  91     $label = $this->randomMachineName();
  92     $definition->setLabel($label);
  93     $this->assertEquals($label, $definition->getLabel());
  94   }
  95
  96   /**
  97    * Tests field description methods.
  98    *
  99    * @covers ::getDescription
 100    */
 101   public function testFieldDescription() {
 102     $definition = BaseFieldDefinition::create($this->fieldType);
 103     $description = $this->randomMachineName();
 104     $definition->setDescription($description);
 105     $this->assertEquals($description, $definition->getDescription());
 106   }
 107
 108   /**
 109    * Tests field type methods.
 110    *
 111    * @covers ::getType
 112    */
 113   public function testFieldType() {
 114     $definition = BaseFieldDefinition::create($this->fieldType);
 115     $this->assertEquals($this->fieldType, $definition->getType());
 116   }
 117
 118   /**
 119    * Tests field settings methods.
 120    *
 121    * @covers ::getSetting
 122    * @covers ::setSetting
 123    * @covers ::getSettings
 124    */
 125   public function testFieldSettings() {
 126     $definition = BaseFieldDefinition::create($this->fieldType);
 127     $setting = $this->randomMachineName();
 128     $value = $this->randomMachineName();
 129     $definition->setSetting($setting, $value);
 130     $this->assertEquals($value, $definition->getSetting($setting));
 131     $default_settings = $this->fieldTypeDefinition['storage_settings'] + $this->fieldTypeDefinition['field_settings'];
 132     $this->assertEquals([$setting => $value] + $default_settings, $definition->getSettings());
 133   }
 134
 135   /**
 136    * Tests the initialization of default field settings.
 137    *
 138    * @covers ::getSetting
 139    * @covers ::setSetting
 140    * @covers ::getSettings
 141    */
 142   public function testDefaultFieldSettings() {
 143     $definition = BaseFieldDefinition::create($this->fieldType);
 144     $expected_settings = $this->fieldTypeDefinition['storage_settings'] + $this->fieldTypeDefinition['field_settings'];
 145     $this->assertEquals($expected_settings, $definition->getSettings());
 146     foreach ($expected_settings as $setting => $value) {
 147       $this->assertEquals($value, $definition->getSetting($setting));
 148     }
 149   }
 150
 151   /**
 152    * Tests field default value.
 153    *
 154    * @covers ::getDefaultValue
 155    * @covers ::setDefaultValue
 156    */
 157   public function testFieldDefaultValue() {
 158     $definition = BaseFieldDefinition::create($this->fieldType);
 159     $default_value = [
 160       'value' => $this->randomMachineName(),
 161     ];
 162     $expected_default_value = [$default_value];
 163     $definition->setDefaultValue($default_value);
 164     $entity = $this->getMockBuilder('Drupal\Core\Entity\ContentEntityBase')
 165       ->disableOriginalConstructor()
 166       ->getMock();
 167     // Set the field item list class to be used to avoid requiring the typed
 168     // data manager to retrieve it.
 169     $definition->setClass('Drupal\Core\Field\FieldItemList');
 170     $this->assertEquals($expected_default_value, $definition->getDefaultValue($entity));
 171
 172     $data_definition = $this->getMockBuilder('Drupal\Core\TypedData\DataDefinition')
 173       ->disableOriginalConstructor()
 174       ->getMock();
 175     $data_definition->expects($this->any())
 176       ->method('getClass')
 177       ->will($this->returnValue('Drupal\Core\Field\FieldItemBase'));
 178     $definition->setItemDefinition($data_definition);
 179
 180     // Set default value only with a literal.
 181     $definition->setDefaultValue($default_value['value']);
 182     $this->assertEquals($expected_default_value, $definition->getDefaultValue($entity));
 183
 184     // Set default value with an indexed array.
 185     $definition->setDefaultValue($expected_default_value);
 186     $this->assertEquals($expected_default_value, $definition->getDefaultValue($entity));
 187
 188     // Set default value with an empty array.
 189     $definition->setDefaultValue([]);
 190     $this->assertEquals([], $definition->getDefaultValue($entity));
 191
 192     // Set default value with NULL.
 193     $definition->setDefaultValue(NULL);
 194     $this->assertEquals([], $definition->getDefaultValue($entity));
 195   }
 196
 197   /**
 198    * Tests field translatable methods.
 199    *
 200    * @covers ::isTranslatable
 201    * @covers ::setTranslatable
 202    */
 203   public function testFieldTranslatable() {
 204     $definition = BaseFieldDefinition::create($this->fieldType);
 205     $this->assertFalse($definition->isTranslatable());
 206     $definition->setTranslatable(TRUE);
 207     $this->assertTrue($definition->isTranslatable());
 208     $definition->setTranslatable(FALSE);
 209     $this->assertFalse($definition->isTranslatable());
 210   }
 211
 212   /**
 213    * Tests field revisionable methods.
 214    *
 215    * @covers ::isRevisionable
 216    * @covers ::setRevisionable
 217    */
 218   public function testFieldRevisionable() {
 219     $definition = BaseFieldDefinition::create($this->fieldType);
 220     $this->assertFalse($definition->isRevisionable());
 221     $definition->setRevisionable(TRUE);
 222     $this->assertTrue($definition->isRevisionable());
 223     $definition->setRevisionable(FALSE);
 224     $this->assertFalse($definition->isRevisionable());
 225   }
 226
 227   /**
 228    * Tests field cardinality.
 229    *
 230    * @covers ::getCardinality
 231    * @covers ::setCardinality
 232    */
 233   public function testFieldCardinality() {
 234     $definition = BaseFieldDefinition::create($this->fieldType);
 235     $this->assertEquals(1, $definition->getCardinality());
 236     $definition->setCardinality(2);
 237     $this->assertEquals(2, $definition->getCardinality());
 238     $definition->setCardinality(FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);
 239     $this->assertEquals(FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED, $definition->getCardinality());
 240   }
 241
 242   /**
 243    * Tests required.
 244    *
 245    * @covers ::isRequired
 246    * @covers ::setRequired
 247    */
 248   public function testFieldRequired() {
 249     $definition = BaseFieldDefinition::create($this->fieldType);
 250     $this->assertFalse($definition->isRequired());
 251     $definition->setRequired(TRUE);
 252     $this->assertTrue($definition->isRequired());
 253     $definition->setRequired(FALSE);
 254     $this->assertFalse($definition->isRequired());
 255   }
 256
 257   /**
 258    * Tests storage required.
 259    *
 260    * @covers ::isStorageRequired
 261    * @covers ::setStorageRequired
 262    */
 263   public function testFieldStorageRequired() {
 264     $definition = BaseFieldDefinition::create($this->fieldType);
 265     $this->assertFalse($definition->isStorageRequired());
 266     $definition->setStorageRequired(TRUE);
 267     $this->assertTrue($definition->isStorageRequired());
 268     $definition->setStorageRequired(FALSE);
 269     $this->assertFalse($definition->isStorageRequired());
 270   }
 271
 272   /**
 273    * Tests provider.
 274    *
 275    * @covers ::getProvider
 276    * @covers ::setProvider
 277    */
 278   public function testFieldProvider() {
 279     $definition = BaseFieldDefinition::create($this->fieldType);
 280     $provider = $this->randomMachineName();
 281     $definition->setProvider($provider);
 282     $this->assertEquals($provider, $definition->getProvider());
 283   }
 284
 285   /**
 286    * Tests custom storage.
 287    *
 288    * @covers ::hasCustomStorage
 289    * @covers ::setCustomStorage
 290    */
 291   public function testCustomStorage() {
 292     $definition = BaseFieldDefinition::create($this->fieldType);
 293     $this->assertFalse($definition->hasCustomStorage());
 294     $definition->setCustomStorage(TRUE);
 295     $this->assertTrue($definition->hasCustomStorage());
 296     $definition->setCustomStorage(FALSE);
 297     $this->assertFalse($definition->hasCustomStorage());
 298   }
 299
 300   /**
 301    * Tests default value callbacks.
 302    *
 303    * @covers ::setDefaultValueCallback
 304    */
 305   public function testDefaultValueCallback() {
 306     $definition = BaseFieldDefinition::create($this->fieldType);
 307     $callback = get_class($this) . '::mockDefaultValueCallback';
 308     // setDefaultValueCallback returns $this.
 309     $this->assertSame($definition, $definition->setDefaultValueCallback($callback));
 310   }
 311
 312   /**
 313    * Tests invalid default value callbacks.
 314    *
 315    * @covers ::setDefaultValueCallback
 316    */
 317   public function testInvalidDefaultValueCallback() {
 318     $definition = BaseFieldDefinition::create($this->fieldType);
 319     // setDefaultValueCallback returns $this.
 320     $this->setExpectedException(\InvalidArgumentException::class);
 321     $definition->setDefaultValueCallback([get_class($this), 'mockDefaultValueCallback']);
 322   }
 323
 324   /**
 325    * Tests NULL default value callbacks.
 326    *
 327    * @covers ::setDefaultValueCallback
 328    */
 329   public function testNullDefaultValueCallback() {
 330     $definition = BaseFieldDefinition::create($this->fieldType);
 331     // setDefaultValueCallback returns $this.
 332     $this->assertSame($definition, $definition->setDefaultValueCallback(NULL));
 333   }
 334
 335   /**
 336    * Provides a Mock base field default value callback.
 337    *
 338    * @param \Drupal\Core\Entity\EntityInterface $entity
 339    *   Entity interface.
 340    * @param \Drupal\Core\Field\FieldDefinitionInterface $definition
 341    *   Field definition.
 342    *
 343    * @return string
 344    *   Default value.
 345    */
 346   public static function mockDefaultValueCallback($entity, $definition) {
 347     return 'a default value';
 348   }
 349
 350 }