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 initial value.
 199    *
 200    * @covers ::getInitialValue
 201    * @covers ::setInitialValue
 202    */
 203   public function testFieldInitialValue() {
 204     $definition = BaseFieldDefinition::create($this->fieldType);
 205     $default_value = [
 206       'value' => $this->randomMachineName(),
 207     ];
 208     $expected_default_value = [$default_value];
 209     $definition->setInitialValue($default_value);
 210     $entity = $this->getMockBuilder('Drupal\Core\Entity\ContentEntityBase')
 211       ->disableOriginalConstructor()
 212       ->getMock();
 213     // Set the field item list class to be used to avoid requiring the typed
 214     // data manager to retrieve it.
 215     $definition->setClass('Drupal\Core\Field\FieldItemList');
 216     $this->assertEquals($expected_default_value, $definition->getInitialValue($entity));
 217
 218     $data_definition = $this->getMockBuilder('Drupal\Core\TypedData\DataDefinition')
 219       ->disableOriginalConstructor()
 220       ->getMock();
 221     $data_definition->expects($this->any())
 222       ->method('getClass')
 223       ->will($this->returnValue('Drupal\Core\Field\FieldItemBase'));
 224     $definition->setItemDefinition($data_definition);
 225
 226     // Set default value only with a literal.
 227     $definition->setInitialValue($default_value['value']);
 228     $this->assertEquals($expected_default_value, $definition->getInitialValue($entity));
 229
 230     // Set default value with an indexed array.
 231     $definition->setInitialValue($expected_default_value);
 232     $this->assertEquals($expected_default_value, $definition->getInitialValue($entity));
 233
 234     // Set default value with an empty array.
 235     $definition->setInitialValue([]);
 236     $this->assertEquals([], $definition->getInitialValue($entity));
 237
 238     // Set default value with NULL.
 239     $definition->setInitialValue(NULL);
 240     $this->assertEquals([], $definition->getInitialValue($entity));
 241   }
 242
 243   /**
 244    * Tests field translatable methods.
 245    *
 246    * @covers ::isTranslatable
 247    * @covers ::setTranslatable
 248    */
 249   public function testFieldTranslatable() {
 250     $definition = BaseFieldDefinition::create($this->fieldType);
 251     $this->assertFalse($definition->isTranslatable());
 252     $definition->setTranslatable(TRUE);
 253     $this->assertTrue($definition->isTranslatable());
 254     $definition->setTranslatable(FALSE);
 255     $this->assertFalse($definition->isTranslatable());
 256   }
 257
 258   /**
 259    * Tests field revisionable methods.
 260    *
 261    * @covers ::isRevisionable
 262    * @covers ::setRevisionable
 263    */
 264   public function testFieldRevisionable() {
 265     $definition = BaseFieldDefinition::create($this->fieldType);
 266     $this->assertFalse($definition->isRevisionable());
 267     $definition->setRevisionable(TRUE);
 268     $this->assertTrue($definition->isRevisionable());
 269     $definition->setRevisionable(FALSE);
 270     $this->assertFalse($definition->isRevisionable());
 271   }
 272
 273   /**
 274    * Tests field cardinality.
 275    *
 276    * @covers ::getCardinality
 277    * @covers ::setCardinality
 278    */
 279   public function testFieldCardinality() {
 280     $definition = BaseFieldDefinition::create($this->fieldType);
 281     $this->assertEquals(1, $definition->getCardinality());
 282     $definition->setCardinality(2);
 283     $this->assertEquals(2, $definition->getCardinality());
 284     $definition->setCardinality(FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);
 285     $this->assertEquals(FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED, $definition->getCardinality());
 286   }
 287
 288   /**
 289    * Tests required.
 290    *
 291    * @covers ::isRequired
 292    * @covers ::setRequired
 293    */
 294   public function testFieldRequired() {
 295     $definition = BaseFieldDefinition::create($this->fieldType);
 296     $this->assertFalse($definition->isRequired());
 297     $definition->setRequired(TRUE);
 298     $this->assertTrue($definition->isRequired());
 299     $definition->setRequired(FALSE);
 300     $this->assertFalse($definition->isRequired());
 301   }
 302
 303   /**
 304    * Tests storage required.
 305    *
 306    * @covers ::isStorageRequired
 307    * @covers ::setStorageRequired
 308    */
 309   public function testFieldStorageRequired() {
 310     $definition = BaseFieldDefinition::create($this->fieldType);
 311     $this->assertFalse($definition->isStorageRequired());
 312     $definition->setStorageRequired(TRUE);
 313     $this->assertTrue($definition->isStorageRequired());
 314     $definition->setStorageRequired(FALSE);
 315     $this->assertFalse($definition->isStorageRequired());
 316   }
 317
 318   /**
 319    * Tests provider.
 320    *
 321    * @covers ::getProvider
 322    * @covers ::setProvider
 323    */
 324   public function testFieldProvider() {
 325     $definition = BaseFieldDefinition::create($this->fieldType);
 326     $provider = $this->randomMachineName();
 327     $definition->setProvider($provider);
 328     $this->assertEquals($provider, $definition->getProvider());
 329   }
 330
 331   /**
 332    * Tests custom storage.
 333    *
 334    * @covers ::hasCustomStorage
 335    * @covers ::setCustomStorage
 336    */
 337   public function testCustomStorage() {
 338     $definition = BaseFieldDefinition::create($this->fieldType);
 339     $this->assertFalse($definition->hasCustomStorage());
 340     $definition->setCustomStorage(TRUE);
 341     $this->assertTrue($definition->hasCustomStorage());
 342     $definition->setCustomStorage(FALSE);
 343     $this->assertFalse($definition->hasCustomStorage());
 344   }
 345
 346   /**
 347    * Tests default value callbacks.
 348    *
 349    * @covers ::setDefaultValueCallback
 350    */
 351   public function testDefaultValueCallback() {
 352     $definition = BaseFieldDefinition::create($this->fieldType);
 353     $callback = get_class($this) . '::mockDefaultValueCallback';
 354     // setDefaultValueCallback returns $this.
 355     $this->assertSame($definition, $definition->setDefaultValueCallback($callback));
 356   }
 357
 358   /**
 359    * Tests invalid default value callbacks.
 360    *
 361    * @covers ::setDefaultValueCallback
 362    */
 363   public function testInvalidDefaultValueCallback() {
 364     $definition = BaseFieldDefinition::create($this->fieldType);
 365     // setDefaultValueCallback returns $this.
 366     $this->setExpectedException(\InvalidArgumentException::class);
 367     $definition->setDefaultValueCallback([get_class($this), 'mockDefaultValueCallback']);
 368   }
 369
 370   /**
 371    * Tests NULL default value callbacks.
 372    *
 373    * @covers ::setDefaultValueCallback
 374    */
 375   public function testNullDefaultValueCallback() {
 376     $definition = BaseFieldDefinition::create($this->fieldType);
 377     // setDefaultValueCallback returns $this.
 378     $this->assertSame($definition, $definition->setDefaultValueCallback(NULL));
 379   }
 380
 381   /**
 382    * Provides a Mock base field default value callback.
 383    *
 384    * @param \Drupal\Core\Entity\EntityInterface $entity
 385    *   Entity interface.
 386    * @param \Drupal\Core\Field\FieldDefinitionInterface $definition
 387    *   Field definition.
 388    *
 389    * @return string
 390    *   Default value.
 391    */
 392   public static function mockDefaultValueCallback($entity, $definition) {
 393     return 'a default value';
 394   }
 395
 396 }