yaffs.net Git - yaffs-website/blob - web/core/tests/Drupal/Tests/Core/Field/FieldItemListTest.php

   1 <?php
   2
   3 namespace Drupal\Tests\Core\Field;
   4
   5 use Drupal\Core\DependencyInjection\ContainerBuilder;
   6 use Drupal\Core\Field\FieldDefinitionInterface;
   7 use Drupal\Core\Field\FieldItemInterface;
   8 use Drupal\Core\Field\FieldItemList;
   9 use Drupal\Core\Field\FieldStorageDefinitionInterface;
  10 use Drupal\Core\Field\FieldTypePluginManagerInterface;
  11 use Drupal\Core\Form\FormState;
  12 use Drupal\Tests\UnitTestCase;
  13
  14 /**
  15  * @coversDefaultClass \Drupal\Core\Field\FieldItemList
  16  * @group Field
  17  */
  18 class FieldItemListTest extends UnitTestCase {
  19
  20   /**
  21    * @covers ::equals
  22    *
  23    * @dataProvider providerTestEquals
  24    */
  25   public function testEquals($expected, FieldItemInterface $first_field_item = NULL, FieldItemInterface $second_field_item = NULL) {
  26
  27     // Mock the field type manager and place it in the container.
  28     $field_type_manager = $this->getMock('Drupal\Core\Field\FieldTypePluginManagerInterface');
  29     $container = new ContainerBuilder();
  30     $container->set('plugin.manager.field.field_type', $field_type_manager);
  31     \Drupal::setContainer($container);
  32
  33     // Set up three properties, one of them being computed.
  34     $property_definitions['0'] = $this->getMock('Drupal\Core\TypedData\DataDefinitionInterface');
  35     $property_definitions['0']->expects($this->any())
  36       ->method('isComputed')
  37       ->willReturn(FALSE);
  38     $property_definitions['1'] = $this->getMock('Drupal\Core\TypedData\DataDefinitionInterface');
  39     $property_definitions['1']->expects($this->any())
  40       ->method('isComputed')
  41       ->willReturn(FALSE);
  42     $property_definitions['2'] = $this->getMock('Drupal\Core\TypedData\DataDefinitionInterface');
  43     $property_definitions['2']->expects($this->any())
  44       ->method('isComputed')
  45       ->willReturn(TRUE);
  46
  47     $field_storage_definition = $this->getMock('Drupal\Core\Field\FieldStorageDefinitionInterface');
  48     $field_storage_definition->expects($this->any())
  49       ->method('getPropertyDefinitions')
  50       ->will($this->returnValue($property_definitions));
  51     $field_definition = $this->getMock('Drupal\Core\Field\FieldDefinitionInterface');
  52     $field_definition->expects($this->any())
  53       ->method('getFieldStorageDefinition')
  54       ->willReturn($field_storage_definition);
  55
  56     $field_list_a = new FieldItemList($field_definition);
  57     $field_list_b = new FieldItemList($field_definition);
  58
  59     // Set up the mocking necessary for creating field items.
  60     $field_type_manager->expects($this->any())
  61       ->method('createFieldItem')
  62       ->willReturnOnConsecutiveCalls($first_field_item, $second_field_item);
  63
  64     // Set the field item values.
  65     if ($first_field_item instanceof FieldItemInterface) {
  66       $field_list_a->setValue($first_field_item);
  67     }
  68     if ($second_field_item instanceof FieldItemInterface) {
  69       $field_list_b->setValue($second_field_item);
  70     }
  71
  72     $this->assertEquals($expected, $field_list_a->equals($field_list_b));
  73   }
  74
  75   /**
  76    * Data provider for testEquals.
  77    */
  78   public function providerTestEquals() {
  79     // Tests field item lists with no values.
  80     $datasets[] = [TRUE];
  81
  82     /** @var \Drupal\Core\Field\FieldItemBase  $field_item_a */
  83     $field_item_a = $this->getMockForAbstractClass('Drupal\Core\Field\FieldItemBase', [], '', FALSE);
  84     $field_item_a->setValue([1]);
  85     // Tests field item lists where one has a value and one does not.
  86     $datasets[] = [FALSE, $field_item_a];
  87
  88     // Tests field item lists where both have the same value.
  89     $datasets[] = [TRUE, $field_item_a, $field_item_a];
  90
  91     /** @var \Drupal\Core\Field\FieldItemBase  $fv */
  92     $field_item_b = $this->getMockForAbstractClass('Drupal\Core\Field\FieldItemBase', [], '', FALSE);
  93     $field_item_b->setValue([2]);
  94     // Tests field item lists where both have the different values.
  95     $datasets[] = [FALSE, $field_item_a, $field_item_b];
  96
  97     /** @var \Drupal\Core\Field\FieldItemBase  $fv */
  98     $field_item_c = $this->getMockForAbstractClass('Drupal\Core\Field\FieldItemBase', [], '', FALSE);
  99     $field_item_c->setValue(['0' => 1, '1' => 2]);
 100     $field_item_d = $this->getMockForAbstractClass('Drupal\Core\Field\FieldItemBase', [], '', FALSE);
 101     $field_item_d->setValue(['1' => 2, '0' => 1]);
 102
 103     // Tests field item lists where both have the differently ordered values.
 104     $datasets[] = [TRUE, $field_item_c, $field_item_d];
 105
 106     /** @var \Drupal\Core\Field\FieldItemBase  $field_item_e */
 107     $field_item_e = $this->getMockForAbstractClass('Drupal\Core\Field\FieldItemBase', [], '', FALSE);
 108     $field_item_e->setValue(['2']);
 109
 110     // Tests field item lists where both have same values but different data
 111     // types.
 112     $datasets[] = [TRUE, $field_item_b, $field_item_e];
 113
 114     /** @var \Drupal\Core\Field\FieldItemBase  $field_item_f */
 115     $field_item_f = $this->getMockForAbstractClass('Drupal\Core\Field\FieldItemBase', [], '', FALSE);
 116     $field_item_f->setValue(['0' => 1, '1' => 2, '2' => 3]);
 117     /** @var \Drupal\Core\Field\FieldItemBase  $field_item_g */
 118     $field_item_g = $this->getMockForAbstractClass('Drupal\Core\Field\FieldItemBase', [], '', FALSE);
 119     $field_item_g->setValue(['0' => 1, '1' => 2, '2' => 4]);
 120
 121     // Tests field item lists where both have same values for the non-computed
 122     // properties ('0' and '1') and a different value for the computed one
 123     // ('2').
 124     $datasets[] = [TRUE, $field_item_f, $field_item_g];
 125
 126     /** @var \Drupal\Core\Field\FieldItemBase  $field_item_h */
 127     $field_item_h = $this->getMockForAbstractClass('Drupal\Core\Field\FieldItemBase', [], '', FALSE);
 128     $field_item_h->setValue(['0' => 1, '1' => 2, '3' => 3]);
 129     /** @var \Drupal\Core\Field\FieldItemBase  $field_item_i */
 130     $field_item_i = $this->getMockForAbstractClass('Drupal\Core\Field\FieldItemBase', [], '', FALSE);
 131     $field_item_i->setValue(['0' => 1, '1' => 2, '3' => 4]);
 132
 133     // Tests field item lists where both have same values for the non-computed
 134     // properties ('0' and '1') and a different value for a property that does
 135     // not exist ('3').
 136     $datasets[] = [TRUE, $field_item_h, $field_item_i];
 137
 138     return $datasets;
 139   }
 140
 141   /**
 142    * Tests identical behavior of ::hasAffectingChanges with ::equals.
 143    *
 144    * @covers ::hasAffectingChanges
 145    *
 146    * @dataProvider providerTestEquals
 147    */
 148   public function testHasAffectingChanges($expected, FieldItemInterface $first_field_item = NULL, FieldItemInterface $second_field_item = NULL) {
 149     // Mock the field type manager and place it in the container.
 150     $field_type_manager = $this->createMock(FieldTypePluginManagerInterface::class);
 151     $container = new ContainerBuilder();
 152     $container->set('plugin.manager.field.field_type', $field_type_manager);
 153     \Drupal::setContainer($container);
 154
 155     $field_storage_definition = $this->createMock(FieldStorageDefinitionInterface::class);
 156     $field_storage_definition->expects($this->any())
 157       ->method('getColumns')
 158       ->willReturn([0 => '0', 1 => '1']);
 159
 160     // Set up three properties, one of them being computed.
 161     $property_definitions['0'] = $this->getMock('Drupal\Core\TypedData\DataDefinitionInterface');
 162     $property_definitions['0']->expects($this->any())
 163       ->method('isComputed')
 164       ->willReturn(FALSE);
 165     $property_definitions['1'] = $this->getMock('Drupal\Core\TypedData\DataDefinitionInterface');
 166     $property_definitions['1']->expects($this->any())
 167       ->method('isComputed')
 168       ->willReturn(FALSE);
 169     $property_definitions['2'] = $this->getMock('Drupal\Core\TypedData\DataDefinitionInterface');
 170     $property_definitions['2']->expects($this->any())
 171       ->method('isComputed')
 172       ->willReturn(TRUE);
 173
 174     $field_storage_definition = $this->getMock('Drupal\Core\Field\FieldStorageDefinitionInterface');
 175     $field_storage_definition->expects($this->any())
 176       ->method('getPropertyDefinitions')
 177       ->will($this->returnValue($property_definitions));
 178
 179     $field_definition = $this->createMock(FieldDefinitionInterface::class);
 180     $field_definition->expects($this->any())
 181       ->method('getFieldStorageDefinition')
 182       ->willReturn($field_storage_definition);
 183     $field_definition->expects($this->any())
 184       ->method('isComputed')
 185       ->willReturn(FALSE);
 186
 187     $field_list_a = new FieldItemList($field_definition);
 188     $field_list_b = new FieldItemList($field_definition);
 189
 190     // Set up the mocking necessary for creating field items.
 191     $field_type_manager->expects($this->any())
 192       ->method('createFieldItem')
 193       ->willReturnOnConsecutiveCalls($first_field_item, $second_field_item);
 194
 195     // Set the field item values.
 196     if ($first_field_item instanceof FieldItemInterface) {
 197       $field_list_a->setValue($first_field_item);
 198     }
 199     if ($second_field_item instanceof FieldItemInterface) {
 200       $field_list_b->setValue($second_field_item);
 201     }
 202
 203     $this->assertEquals($expected, !$field_list_a->hasAffectingChanges($field_list_b, ''));
 204   }
 205
 206   /**
 207    * @covers ::equals
 208    */
 209   public function testEqualsEmptyItems() {
 210     /** @var \Drupal\Core\Field\FieldItemBase  $fv */
 211     $first_field_item = $this->getMockForAbstractClass('Drupal\Core\Field\FieldItemBase', [], '', FALSE);
 212     $first_field_item->setValue(['0' => 1, '1' => 2]);
 213     $second_field_item = $this->getMockForAbstractClass('Drupal\Core\Field\FieldItemBase', [], '', FALSE);
 214     $second_field_item->setValue(['1' => 2, '0' => 1]);
 215     $empty_field_item = $this->getMockForAbstractClass('Drupal\Core\Field\FieldItemBase', [], '', FALSE);
 216     // Mock the field type manager and place it in the container.
 217     $field_type_manager = $this->getMock('Drupal\Core\Field\FieldTypePluginManagerInterface');
 218     $container = new ContainerBuilder();
 219     $container->set('plugin.manager.field.field_type', $field_type_manager);
 220     \Drupal::setContainer($container);
 221
 222     // Set up the properties of the field item.
 223     $property_definitions['0'] = $this->getMock('Drupal\Core\TypedData\DataDefinitionInterface');
 224     $property_definitions['0']->expects($this->any())
 225       ->method('isComputed')
 226       ->willReturn(FALSE);
 227     $property_definitions['1'] = $this->getMock('Drupal\Core\TypedData\DataDefinitionInterface');
 228     $property_definitions['1']->expects($this->any())
 229       ->method('isComputed')
 230       ->willReturn(FALSE);
 231
 232     $field_storage_definition = $this->getMock('Drupal\Core\Field\FieldStorageDefinitionInterface');
 233     $field_storage_definition->expects($this->any())
 234       ->method('getPropertyDefinitions')
 235       ->will($this->returnValue($property_definitions));
 236     $field_definition = $this->getMock('Drupal\Core\Field\FieldDefinitionInterface');
 237     $field_definition->expects($this->any())
 238       ->method('getFieldStorageDefinition')
 239       ->willReturn($field_storage_definition);
 240
 241     $field_list_a = new FieldItemList($field_definition);
 242     $field_list_b = new FieldItemList($field_definition);
 243
 244     // Set up the mocking necessary for creating field items.
 245     $field_type_manager->expects($this->any())
 246       ->method('createFieldItem')
 247       ->willReturnOnConsecutiveCalls($first_field_item, $second_field_item, $empty_field_item, $empty_field_item);
 248
 249     // Set the field item values.
 250     $field_list_a->setValue($first_field_item);
 251     $field_list_b->setValue($second_field_item);
 252     $field_list_a->appendItem($empty_field_item);
 253
 254     // Field list A has an empty item.
 255     $this->assertEquals(FALSE, $field_list_a->equals($field_list_b));
 256
 257     // Field lists A and B have empty items.
 258     $field_list_b->appendItem($empty_field_item);
 259     $this->assertEquals(TRUE, $field_list_a->equals($field_list_b));
 260
 261     // Field list B has an empty item.
 262     $field_list_a->filterEmptyItems();
 263     $this->assertEquals(FALSE, $field_list_a->equals($field_list_b));
 264
 265     // Neither field lists A and B have empty items.
 266     $field_list_b->filterEmptyItems();
 267     $this->assertEquals(TRUE, $field_list_a->equals($field_list_b));
 268   }
 269
 270   /**
 271    * @covers ::defaultValuesForm
 272    */
 273   public function testDefaultValuesForm() {
 274     $field_definition = $this->getMock(FieldDefinitionInterface::class);
 275     $field_definition->expects($this->any())
 276       ->method('getType')
 277       ->willReturn('field_type');
 278     /** @var \Drupal\Core\Field\FieldItemList|\PHPUnit_Framework_MockObject_MockObject $field_list */
 279     $field_list = $this->getMock(FieldItemList::class, ['defaultValueWidget'], [$field_definition]);
 280     $field_list->expects($this->any())
 281       ->method('defaultValueWidget')
 282       ->willReturn(NULL);
 283     $form = [];
 284     $form_state = new FormState();
 285     $string_translation = $this->getStringTranslationStub();
 286     $field_list->setStringTranslation($string_translation);
 287
 288     $this->assertEquals('No widget available for: <em class="placeholder">field_type</em>.', $field_list->defaultValuesForm($form, $form_state)['#markup']);
 289   }
 290
 291   /**
 292    * @covers ::defaultValuesFormValidate
 293    */
 294   public function testDefaultValuesFormValidate() {
 295     $field_definition = $this->getMock(FieldDefinitionInterface::class);
 296     /** @var \Drupal\Core\Field\FieldItemList|\PHPUnit_Framework_MockObject_MockObject $field_list */
 297     $field_list = $this->getMock(FieldItemList::class, ['defaultValueWidget', 'validate'], [$field_definition]);
 298     $field_list->expects($this->any())
 299       ->method('defaultValueWidget')
 300       ->willReturn(NULL);
 301     $field_list->expects($this->never())
 302       ->method('validate');
 303     $form = [];
 304     $form_state = new FormState();
 305
 306     $field_list->defaultValuesFormValidate([], $form, $form_state);
 307   }
 308
 309   /**
 310    * @covers ::defaultValuesFormSubmit
 311    */
 312   public function testDefaultValuesFormSubmit() {
 313     $field_definition = $this->getMock(FieldDefinitionInterface::class);
 314     /** @var \Drupal\Core\Field\FieldItemList|\PHPUnit_Framework_MockObject_MockObject $field_list */
 315     $field_list = $this->getMock(FieldItemList::class, ['defaultValueWidget', 'getValue'], [$field_definition]);
 316     $field_list->expects($this->any())
 317       ->method('defaultValueWidget')
 318       ->willReturn(NULL);
 319     $form = [];
 320     $form_state = new FormState();
 321     $field_list->expects($this->never())
 322       ->method('getValue');
 323
 324     $this->assertNull($field_list->defaultValuesFormSubmit([], $form, $form_state));
 325   }
 326
 327 }