yaffs.net Git - yaffs-website/blob - web/core/tests/Drupal/KernelTests/Core/Entity/FieldSqlStorageTest.php

   1 <?php
   2
   3 namespace Drupal\KernelTests\Core\Entity;
   4
   5 use Drupal\Component\Utility\Unicode;
   6 use Drupal\Core\Database\Database;
   7 use Drupal\Core\Entity\Exception\FieldStorageDefinitionUpdateForbiddenException;
   8 use Drupal\field\Entity\FieldConfig;
   9 use Drupal\field\Entity\FieldStorageConfig;
  10
  11 /**
  12  * Tests Field SQL Storage .
  13  *
  14  * Field_sql_storage.module implements the default back-end storage plugin
  15  * for the Field Storage API.
  16  *
  17  * @group Entity
  18  */
  19 class FieldSqlStorageTest extends EntityKernelTestBase {
  20
  21   /**
  22    * Modules to enable.
  23    *
  24    * @var array
  25    */
  26   public static $modules = ['field', 'field_test', 'text', 'entity_test'];
  27
  28   /**
  29    * The name of the created field.
  30    *
  31    * @var string
  32    */
  33   protected $fieldName;
  34
  35   /**
  36    * @var int
  37    */
  38   protected $fieldCardinality;
  39
  40   /**
  41    * A field storage to use in this class.
  42    *
  43    * @var \Drupal\field\Entity\FieldStorageConfig
  44    */
  45   protected $fieldStorage;
  46
  47   /**
  48    * A field to use in this test class.
  49    *
  50    * @var \Drupal\field\Entity\FieldConfig
  51    */
  52   protected $field;
  53
  54   /**
  55    * Name of the data table of the field.
  56    *
  57    * @var string
  58    */
  59   protected $table;
  60
  61   /**
  62    * Name of the revision table of the field.
  63    *
  64    * @var string
  65    */
  66   protected $revisionTable;
  67
  68   /**
  69    * The table mapping for the tested entity type.
  70    *
  71    * @var \Drupal\Core\Entity\Sql\DefaultTableMapping $table_mapping
  72    */
  73   protected $tableMapping;
  74
  75   protected function setUp() {
  76     parent::setUp();
  77
  78     $this->installEntitySchema('entity_test_rev');
  79     $entity_type = 'entity_test_rev';
  80
  81     $this->fieldName = strtolower($this->randomMachineName());
  82     $this->fieldCardinality = 4;
  83     $this->fieldStorage = FieldStorageConfig::create([
  84       'field_name' => $this->fieldName,
  85       'entity_type' => $entity_type,
  86       'type' => 'test_field',
  87       'cardinality' => $this->fieldCardinality,
  88     ]);
  89     $this->fieldStorage->save();
  90     $this->field = FieldConfig::create([
  91       'field_storage' => $this->fieldStorage,
  92       'bundle' => $entity_type
  93     ]);
  94     $this->field->save();
  95
  96     /** @var \Drupal\Core\Entity\Sql\DefaultTableMapping $table_mapping */
  97     $table_mapping = \Drupal::entityManager()->getStorage($entity_type)->getTableMapping();
  98     $this->tableMapping = $table_mapping;
  99     $this->table = $table_mapping->getDedicatedDataTableName($this->fieldStorage);
 100     $this->revisionTable = $table_mapping->getDedicatedRevisionTableName($this->fieldStorage);
 101   }
 102
 103   /**
 104    * Tests field loading works correctly by inserting directly in the tables.
 105    */
 106   public function testFieldLoad() {
 107     $entity_type = $bundle = 'entity_test_rev';
 108     $storage = $this->container->get('entity.manager')->getStorage($entity_type);
 109
 110     $columns = ['bundle', 'deleted', 'entity_id', 'revision_id', 'delta', 'langcode', $this->tableMapping->getFieldColumnName($this->fieldStorage, 'value')];
 111
 112     // Create an entity with four revisions.
 113     $revision_ids = [];
 114     $entity = $this->container->get('entity_type.manager')
 115       ->getStorage($entity_type)
 116       ->create();
 117     $entity->save();
 118     $revision_ids[] = $entity->getRevisionId();
 119     for ($i = 0; $i < 4; $i++) {
 120       $entity->setNewRevision();
 121       $entity->save();
 122       $revision_ids[] = $entity->getRevisionId();
 123     }
 124
 125     // Generate values and insert them directly in the storage tables.
 126     $values = [];
 127     $query = db_insert($this->revisionTable)->fields($columns);
 128     foreach ($revision_ids as $revision_id) {
 129       // Put one value too many.
 130       for ($delta = 0; $delta <= $this->fieldCardinality; $delta++) {
 131         $value = mt_rand(1, 127);
 132         $values[$revision_id][] = $value;
 133         $query->values([$bundle, 0, $entity->id(), $revision_id, $delta, $entity->language()->getId(), $value]);
 134       }
 135       $query->execute();
 136     }
 137     $query = db_insert($this->table)->fields($columns);
 138     foreach ($values[$revision_id] as $delta => $value) {
 139       $query->values([$bundle, 0, $entity->id(), $revision_id, $delta, $entity->language()->getId(), $value]);
 140     }
 141     $query->execute();
 142
 143     // Load every revision and check the values.
 144     foreach ($revision_ids as $revision_id) {
 145       $entity = $storage->loadRevision($revision_id);
 146       foreach ($values[$revision_id] as $delta => $value) {
 147         if ($delta < $this->fieldCardinality) {
 148           $this->assertEqual($entity->{$this->fieldName}[$delta]->value, $value);
 149         }
 150         else {
 151           $this->assertFalse(array_key_exists($delta, $entity->{$this->fieldName}));
 152         }
 153       }
 154     }
 155
 156     // Load the "current revision" and check the values.
 157     $entity = $storage->load($entity->id());
 158     foreach ($values[$revision_id] as $delta => $value) {
 159       if ($delta < $this->fieldCardinality) {
 160         $this->assertEqual($entity->{$this->fieldName}[$delta]->value, $value);
 161       }
 162       else {
 163         $this->assertFalse(array_key_exists($delta, $entity->{$this->fieldName}));
 164       }
 165     }
 166
 167     // Add a translation in an unavailable language code and verify it is not
 168     // loaded.
 169     $unavailable_langcode = 'xx';
 170     $values = [$bundle, 0, $entity->id(), $entity->getRevisionId(), 0, $unavailable_langcode, mt_rand(1, 127)];
 171     db_insert($this->table)->fields($columns)->values($values)->execute();
 172     db_insert($this->revisionTable)->fields($columns)->values($values)->execute();
 173     $entity = $storage->load($entity->id());
 174     $this->assertFalse(array_key_exists($unavailable_langcode, $entity->{$this->fieldName}));
 175   }
 176
 177   /**
 178    * Tests field saving works correctly by reading directly from the tables.
 179    */
 180   public function testFieldWrite() {
 181     $entity_type = $bundle = 'entity_test_rev';
 182     $entity = $this->container->get('entity_type.manager')
 183       ->getStorage($entity_type)
 184       ->create();
 185
 186     $revision_values = [];
 187
 188     // Check insert. Add one value too many.
 189     $values = [];
 190     for ($delta = 0; $delta <= $this->fieldCardinality; $delta++) {
 191       $values[$delta]['value'] = mt_rand(1, 127);
 192     }
 193     $entity->{$this->fieldName} = $values;
 194     $entity->save();
 195
 196     // Read the tables and check the correct values have been stored.
 197     $rows = db_select($this->table, 't')->fields('t')->execute()->fetchAllAssoc('delta', \PDO::FETCH_ASSOC);
 198     $this->assertEqual(count($rows), $this->fieldCardinality);
 199     foreach ($rows as $delta => $row) {
 200       $expected = [
 201         'bundle' => $bundle,
 202         'deleted' => 0,
 203         'entity_id' => $entity->id(),
 204         'revision_id' => $entity->getRevisionId(),
 205         'langcode' => $entity->language()->getId(),
 206         'delta' => $delta,
 207         $this->fieldName . '_value' => $values[$delta]['value'],
 208       ];
 209       $this->assertEqual($row, $expected, "Row $delta was stored as expected.");
 210     }
 211
 212     // Test update. Add less values and check that the previous values did not
 213     // persist.
 214     $values = [];
 215     for ($delta = 0; $delta <= $this->fieldCardinality - 2; $delta++) {
 216       $values[$delta]['value'] = mt_rand(1, 127);
 217     }
 218     $entity->{$this->fieldName} = $values;
 219     $entity->save();
 220     $rows = db_select($this->table, 't')->fields('t')->execute()->fetchAllAssoc('delta', \PDO::FETCH_ASSOC);
 221     $this->assertEqual(count($rows), count($values));
 222     foreach ($rows as $delta => $row) {
 223       $expected = [
 224         'bundle' => $bundle,
 225         'deleted' => 0,
 226         'entity_id' => $entity->id(),
 227         'revision_id' => $entity->getRevisionId(),
 228         'langcode' => $entity->language()->getId(),
 229         'delta' => $delta,
 230         $this->fieldName . '_value' => $values[$delta]['value'],
 231       ];
 232       $this->assertEqual($row, $expected, "Row $delta was stored as expected.");
 233     }
 234
 235     // Create a new revision.
 236     $revision_values[$entity->getRevisionId()] = $values;
 237     $values = [];
 238     for ($delta = 0; $delta < $this->fieldCardinality; $delta++) {
 239       $values[$delta]['value'] = mt_rand(1, 127);
 240     }
 241     $entity->{$this->fieldName} = $values;
 242     $entity->setNewRevision();
 243     $entity->save();
 244     $revision_values[$entity->getRevisionId()] = $values;
 245
 246     // Check that data for both revisions are in the revision table.
 247     foreach ($revision_values as $revision_id => $values) {
 248       $rows = db_select($this->revisionTable, 't')->fields('t')->condition('revision_id', $revision_id)->execute()->fetchAllAssoc('delta', \PDO::FETCH_ASSOC);
 249       $this->assertEqual(count($rows), min(count($values), $this->fieldCardinality));
 250       foreach ($rows as $delta => $row) {
 251         $expected = [
 252           'bundle' => $bundle,
 253           'deleted' => 0,
 254           'entity_id' => $entity->id(),
 255           'revision_id' => $revision_id,
 256           'langcode' => $entity->language()->getId(),
 257           'delta' => $delta,
 258           $this->fieldName . '_value' => $values[$delta]['value'],
 259         ];
 260         $this->assertEqual($row, $expected, "Row $delta was stored as expected.");
 261       }
 262     }
 263
 264     // Test emptying the field.
 265     $entity->{$this->fieldName} = NULL;
 266     $entity->save();
 267     $rows = db_select($this->table, 't')->fields('t')->execute()->fetchAllAssoc('delta', \PDO::FETCH_ASSOC);
 268     $this->assertEqual(count($rows), 0);
 269   }
 270
 271   /**
 272    * Tests that long entity type and field names do not break.
 273    */
 274   public function testLongNames() {
 275     // Use one of the longest entity_type names in core.
 276     $entity_type = $bundle = 'entity_test_label_callback';
 277     $this->installEntitySchema('entity_test_label_callback');
 278     $storage = $this->container->get('entity.manager')->getStorage($entity_type);
 279
 280     // Create two fields and generate random values.
 281     $name_base = Unicode::strtolower($this->randomMachineName(FieldStorageConfig::NAME_MAX_LENGTH - 1));
 282     $field_names = [];
 283     $values = [];
 284     for ($i = 0; $i < 2; $i++) {
 285       $field_names[$i] = $name_base . $i;
 286       FieldStorageConfig::create([
 287         'field_name' => $field_names[$i],
 288         'entity_type' => $entity_type,
 289         'type' => 'test_field',
 290       ])->save();
 291       FieldConfig::create([
 292         'field_name' => $field_names[$i],
 293         'entity_type' => $entity_type,
 294         'bundle' => $bundle,
 295       ])->save();
 296       $values[$field_names[$i]] = mt_rand(1, 127);
 297     }
 298
 299     // Save an entity with values.
 300     $entity = $this->container->get('entity_type.manager')
 301       ->getStorage($entity_type)
 302       ->create($values);
 303     $entity->save();
 304
 305     // Load the entity back and check the values.
 306     $entity = $storage->load($entity->id());
 307     foreach ($field_names as $field_name) {
 308       $this->assertEqual($entity->get($field_name)->value, $values[$field_name]);
 309     }
 310   }
 311
 312   /**
 313    * Test trying to update a field with data.
 314    */
 315   public function testUpdateFieldSchemaWithData() {
 316     $entity_type = 'entity_test_rev';
 317     // Create a decimal 5.2 field and add some data.
 318     $field_storage = FieldStorageConfig::create([
 319       'field_name' => 'decimal52',
 320       'entity_type' => $entity_type,
 321       'type' => 'decimal',
 322       'settings' => ['precision' => 5, 'scale' => 2],
 323     ]);
 324     $field_storage->save();
 325     $field = FieldConfig::create([
 326       'field_storage' => $field_storage,
 327       'bundle' => $entity_type,
 328     ]);
 329     $field->save();
 330     $entity = $this->container->get('entity_type.manager')
 331       ->getStorage($entity_type)
 332       ->create([
 333         'id' => 0,
 334         'revision_id' => 0,
 335       ]);
 336     $entity->decimal52->value = '1.235';
 337     $entity->save();
 338
 339     // Attempt to update the field in a way that would work without data.
 340     $field_storage->setSetting('scale', 3);
 341     try {
 342       $field_storage->save();
 343       $this->fail(t('Cannot update field schema with data.'));
 344     }
 345     catch (FieldStorageDefinitionUpdateForbiddenException $e) {
 346       $this->pass(t('Cannot update field schema with data.'));
 347     }
 348   }
 349
 350   /**
 351    * Test that failure to create fields is handled gracefully.
 352    */
 353   public function testFieldUpdateFailure() {
 354     // Create a text field.
 355     $field_storage = FieldStorageConfig::create([
 356       'field_name' => 'test_text',
 357       'entity_type' => 'entity_test_rev',
 358       'type' => 'text',
 359       'settings' => ['max_length' => 255],
 360     ]);
 361     $field_storage->save();
 362
 363     // Attempt to update the field in a way that would break the storage. The
 364     // parenthesis suffix is needed because SQLite has *very* relaxed rules for
 365     // data types, so we actually need to provide an invalid SQL syntax in order
 366     // to break it.
 367     // @see https://www.sqlite.org/datatype3.html
 368     $prior_field_storage = $field_storage;
 369     $field_storage->setSetting('max_length', '-1)');
 370     try {
 371       $field_storage->save();
 372       $this->fail(t('Update succeeded.'));
 373     }
 374     catch (\Exception $e) {
 375       $this->pass(t('Update properly failed.'));
 376     }
 377
 378     // Ensure that the field tables are still there.
 379     $tables = [
 380       $this->tableMapping->getDedicatedDataTableName($prior_field_storage),
 381       $this->tableMapping->getDedicatedRevisionTableName($prior_field_storage),
 382     ];
 383     foreach ($tables as $table_name) {
 384       $this->assertTrue(db_table_exists($table_name), t('Table %table exists.', ['%table' => $table_name]));
 385     }
 386   }
 387
 388   /**
 389    * Test adding and removing indexes while data is present.
 390    */
 391   public function testFieldUpdateIndexesWithData() {
 392     // Create a decimal field.
 393     $field_name = 'testfield';
 394     $entity_type = 'entity_test_rev';
 395     $field_storage = FieldStorageConfig::create([
 396       'field_name' => $field_name,
 397       'entity_type' => $entity_type,
 398       'type' => 'text',
 399     ]);
 400     $field_storage->save();
 401     $field = FieldConfig::create([
 402       'field_storage' => $field_storage,
 403       'bundle' => $entity_type,
 404     ]);
 405     $field->save();
 406     $tables = [$this->tableMapping->getDedicatedDataTableName($field_storage), $this->tableMapping->getDedicatedRevisionTableName($field_storage)];
 407
 408     // Verify the indexes we will create do not exist yet.
 409     foreach ($tables as $table) {
 410       $this->assertFalse(Database::getConnection()->schema()->indexExists($table, 'value'), t("No index named value exists in @table", ['@table' => $table]));
 411       $this->assertFalse(Database::getConnection()->schema()->indexExists($table, 'value_format'), t("No index named value_format exists in @table", ['@table' => $table]));
 412     }
 413
 414     // Add data so the table cannot be dropped.
 415     $entity = $this->container->get('entity_type.manager')
 416       ->getStorage($entity_type)
 417       ->create([
 418         'id' => 1,
 419         'revision_id' => 1,
 420       ]);
 421     $entity->$field_name->value = 'field data';
 422     $entity->enforceIsNew();
 423     $entity->save();
 424
 425     // Add an index.
 426     $field_storage->setIndexes(['value' => [['value', 255]]]);
 427     $field_storage->save();
 428     foreach ($tables as $table) {
 429       $this->assertTrue(Database::getConnection()->schema()->indexExists($table, "{$field_name}_value"), t("Index on value created in @table", ['@table' => $table]));
 430     }
 431
 432     // Add a different index, removing the existing custom one.
 433     $field_storage->setIndexes(['value_format' => [['value', 127], ['format', 127]]]);
 434     $field_storage->save();
 435     foreach ($tables as $table) {
 436       $this->assertTrue(Database::getConnection()->schema()->indexExists($table, "{$field_name}_value_format"), t("Index on value_format created in @table", ['@table' => $table]));
 437       $this->assertFalse(Database::getConnection()->schema()->indexExists($table, "{$field_name}_value"), t("Index on value removed in @table", ['@table' => $table]));
 438     }
 439
 440     // Verify that the tables were not dropped in the process.
 441     $entity = $this->container->get('entity.manager')->getStorage($entity_type)->load(1);
 442     $this->assertEqual($entity->$field_name->value, 'field data', t("Index changes performed without dropping the tables"));
 443   }
 444
 445   /**
 446    * Test foreign key support.
 447    */
 448   public function testFieldSqlStorageForeignKeys() {
 449     // Create a 'shape' field, with a configurable foreign key (see
 450     // field_test_field_schema()).
 451     $field_name = 'testfield';
 452     $foreign_key_name = 'shape';
 453     $field_storage = FieldStorageConfig::create([
 454       'field_name' => $field_name,
 455       'entity_type' => 'entity_test',
 456       'type' => 'shape',
 457       'settings' => ['foreign_key_name' => $foreign_key_name],
 458     ]);
 459     $field_storage->save();
 460     // Get the field schema.
 461     $schema = $field_storage->getSchema();
 462
 463     // Retrieve the field definition and check that the foreign key is in place.
 464     $this->assertEqual($schema['foreign keys'][$foreign_key_name]['table'], $foreign_key_name, 'Foreign key table name preserved through CRUD');
 465     $this->assertEqual($schema['foreign keys'][$foreign_key_name]['columns'][$foreign_key_name], 'id', 'Foreign key column name preserved through CRUD');
 466
 467     // Update the field settings, it should update the foreign key definition too.
 468     $foreign_key_name = 'color';
 469     $field_storage->setSetting('foreign_key_name', $foreign_key_name);
 470     $field_storage->save();
 471     // Reload the field schema after the update.
 472     $schema = $field_storage->getSchema();
 473
 474     // Check that the foreign key is in place.
 475     $this->assertEqual($schema['foreign keys'][$foreign_key_name]['table'], $foreign_key_name, 'Foreign key table name modified after update');
 476     $this->assertEqual($schema['foreign keys'][$foreign_key_name]['columns'][$foreign_key_name], 'id', 'Foreign key column name modified after update');
 477   }
 478
 479   /**
 480    * Tests table name generation.
 481    */
 482   public function testTableNames() {
 483     // Note: we need to test entity types with long names. We therefore use
 484     // fields on imaginary entity types (works as long as we don't actually save
 485     // them), and just check the generated table names.
 486
 487     // Short entity type and field name.
 488     $entity_type = 'short_entity_type';
 489     $field_name = 'short_field_name';
 490     $field_storage = FieldStorageConfig::create([
 491       'entity_type' => $entity_type,
 492       'field_name' => $field_name,
 493       'type' => 'test_field',
 494     ]);
 495     $expected = 'short_entity_type__short_field_name';
 496     $this->assertEqual($this->tableMapping->getDedicatedDataTableName($field_storage), $expected);
 497     $expected = 'short_entity_type_revision__short_field_name';
 498     $this->assertEqual($this->tableMapping->getDedicatedRevisionTableName($field_storage), $expected);
 499
 500     // Short entity type, long field name
 501     $entity_type = 'short_entity_type';
 502     $field_name = 'long_field_name_abcdefghijklmnopqrstuvwxyz';
 503     $field_storage = FieldStorageConfig::create([
 504       'entity_type' => $entity_type,
 505       'field_name' => $field_name,
 506       'type' => 'test_field',
 507     ]);
 508     $expected = 'short_entity_type__' . substr(hash('sha256', $field_storage->uuid()), 0, 10);
 509     $this->assertEqual($this->tableMapping->getDedicatedDataTableName($field_storage), $expected);
 510     $expected = 'short_entity_type_r__' . substr(hash('sha256', $field_storage->uuid()), 0, 10);
 511     $this->assertEqual($this->tableMapping->getDedicatedRevisionTableName($field_storage), $expected);
 512
 513     // Long entity type, short field name
 514     $entity_type = 'long_entity_type_abcdefghijklmnopqrstuvwxyz';
 515     $field_name = 'short_field_name';
 516     $field_storage = FieldStorageConfig::create([
 517       'entity_type' => $entity_type,
 518       'field_name' => $field_name,
 519       'type' => 'test_field',
 520     ]);
 521     $expected = 'long_entity_type_abcdefghijklmnopq__' . substr(hash('sha256', $field_storage->uuid()), 0, 10);
 522     $this->assertEqual($this->tableMapping->getDedicatedDataTableName($field_storage), $expected);
 523     $expected = 'long_entity_type_abcdefghijklmnopq_r__' . substr(hash('sha256', $field_storage->uuid()), 0, 10);
 524     $this->assertEqual($this->tableMapping->getDedicatedRevisionTableName($field_storage), $expected);
 525
 526     // Long entity type and field name.
 527     $entity_type = 'long_entity_type_abcdefghijklmnopqrstuvwxyz';
 528     $field_name = 'long_field_name_abcdefghijklmnopqrstuvwxyz';
 529     $field_storage = FieldStorageConfig::create([
 530       'entity_type' => $entity_type,
 531       'field_name' => $field_name,
 532       'type' => 'test_field',
 533     ]);
 534     $expected = 'long_entity_type_abcdefghijklmnopq__' . substr(hash('sha256', $field_storage->uuid()), 0, 10);
 535     $this->assertEqual($this->tableMapping->getDedicatedDataTableName($field_storage), $expected);
 536     $expected = 'long_entity_type_abcdefghijklmnopq_r__' . substr(hash('sha256', $field_storage->uuid()), 0, 10);
 537     $this->assertEqual($this->tableMapping->getDedicatedRevisionTableName($field_storage), $expected);
 538     // Try creating a second field and check there are no clashes.
 539     $field_storage2 = FieldStorageConfig::create([
 540       'entity_type' => $entity_type,
 541       'field_name' => $field_name . '2',
 542       'type' => 'test_field',
 543     ]);
 544     $this->assertNotEqual($this->tableMapping->getDedicatedDataTableName($field_storage), $this->tableMapping->getDedicatedDataTableName($field_storage2));
 545     $this->assertNotEqual($this->tableMapping->getDedicatedRevisionTableName($field_storage), $this->tableMapping->getDedicatedRevisionTableName($field_storage2));
 546
 547     // Deleted field.
 548     $field_storage = FieldStorageConfig::create([
 549       'entity_type' => 'some_entity_type',
 550       'field_name' => 'some_field_name',
 551       'type' => 'test_field',
 552       'deleted' => TRUE,
 553     ]);
 554     $expected = 'field_deleted_data_' . substr(hash('sha256', $field_storage->uuid()), 0, 10);
 555     $this->assertEqual($this->tableMapping->getDedicatedDataTableName($field_storage, TRUE), $expected);
 556     $expected = 'field_deleted_revision_' . substr(hash('sha256', $field_storage->uuid()), 0, 10);
 557     $this->assertEqual($this->tableMapping->getDedicatedRevisionTableName($field_storage, TRUE), $expected);
 558   }
 559
 560 }