field_sql_storage.test 18.8 KB
Newer Older
Dries's avatar
 
Dries committed
1 2
<?php

3
use Drupal\Core\Database\Database;
4
use Drupal\field\FieldException;
5
use Drupal\simpletest\WebTestBase;
6

7 8
/**
 * @file
9
 * Tests for field_sql_storage.module.
10 11 12 13 14 15 16 17
 *
 * Field_sql_storage.module implements the default back-end storage plugin
 * for the Field Strage API.
 */

/**
 * Tests field storage.
 */
18
class FieldSqlStorageTestCase extends WebTestBase {
19
  public static function getInfo() {
Dries's avatar
 
Dries committed
20
    return array(
21 22
      'name'  => 'Field SQL Storage tests',
      'description'  => "Test Field SQL Storage module.",
23
      'group' => 'Field API'
Dries's avatar
 
Dries committed
24 25 26 27
    );
  }

  function setUp() {
28
    parent::setUp('field_sql_storage', 'field', 'field_test', 'text', 'number');
29
    $this->field_name = strtolower($this->randomName());
30
    $this->field = array('field_name' => $this->field_name, 'type' => 'test_field', 'cardinality' => 4);
31
    $this->field = field_create_field($this->field);
32 33
    $this->instance = array(
      'field_name' => $this->field_name,
34
      'entity_type' => 'test_entity',
35 36
      'bundle' => 'test_bundle'
    );
37 38 39
    $this->instance = field_create_instance($this->instance);
    $this->table = _field_sql_storage_tablename($this->field);
    $this->revision_table = _field_sql_storage_revision_tablename($this->field);
40

Dries's avatar
 
Dries committed
41 42
  }

43 44 45 46 47 48 49
  /**
   * Uses the mysql tables and records to verify
   * field_load_revision works correctly.
   */
  function testFieldAttachLoad() {
    $entity_type = 'test_entity';
    $eid = 0;
50
    $langcode = LANGUAGE_NOT_SPECIFIED;
51

52
    $columns = array('entity_type', 'entity_id', 'revision_id', 'delta', 'langcode', $this->field_name . '_value');
53 54 55 56 57 58 59 60 61

    // Insert data for four revisions to the field revisions table
    $query = db_insert($this->revision_table)->fields($columns);
    for ($evid = 0; $evid < 4; ++$evid) {
      $values[$evid] = array();
      // Note: we insert one extra value ('<=' instead of '<').
      for ($delta = 0; $delta <= $this->field['cardinality']; $delta++) {
        $value = mt_rand(1, 127);
        $values[$evid][] = $value;
62
        $query->values(array($entity_type, $eid, $evid, $delta, $langcode, $value));
63 64 65 66 67 68 69
      }
    }
    $query->execute();

    // Insert data for the "most current revision" into the field table
    $query = db_insert($this->table)->fields($columns);
    foreach ($values[0] as $delta => $value) {
70
      $query->values(array($entity_type, $eid, 0, $delta, $langcode, $value));
71 72 73 74 75 76 77 78
    }
    $query->execute();

    // Load the "most current revision"
    $entity = field_test_create_stub_entity($eid, 0, $this->instance['bundle']);
    field_attach_load($entity_type, array($eid => $entity));
    foreach ($values[0] as $delta => $value) {
      if ($delta < $this->field['cardinality']) {
79
        $this->assertEqual($entity->{$this->field_name}[$langcode][$delta]['value'], $value, "Value $delta is loaded correctly for current revision");
80 81
      }
      else {
82
        $this->assertFalse(array_key_exists($delta, $entity->{$this->field_name}[$langcode]), "No extraneous value gets loaded for current revision.");
83 84 85 86 87 88 89 90 91
      }
    }

    // Load every revision
    for ($evid = 0; $evid < 4; ++$evid) {
      $entity = field_test_create_stub_entity($eid, $evid, $this->instance['bundle']);
      field_attach_load_revision($entity_type, array($eid => $entity));
      foreach ($values[$evid] as $delta => $value) {
        if ($delta < $this->field['cardinality']) {
92
          $this->assertEqual($entity->{$this->field_name}[$langcode][$delta]['value'], $value, "Value $delta for revision $evid is loaded correctly");
93 94
        }
        else {
95
          $this->assertFalse(array_key_exists($delta, $entity->{$this->field_name}[$langcode]), "No extraneous value gets loaded for revision $evid.");
96 97 98
        }
      }
    }
99

100 101
    // Add a translation in an unavailable language code and verify it is not
    // loaded.
102
    $eid = $evid = 1;
103
    $unavailable_langcode = 'xx';
104
    $entity = field_test_create_stub_entity($eid, $evid, $this->instance['bundle']);
105
    $values = array($entity_type, $eid, $evid, 0, $unavailable_langcode, mt_rand(1, 127));
106 107 108
    db_insert($this->table)->fields($columns)->values($values)->execute();
    db_insert($this->revision_table)->fields($columns)->values($values)->execute();
    field_attach_load($entity_type, array($eid => $entity));
109
    $this->assertFalse(array_key_exists($unavailable_langcode, $entity->{$this->field_name}), 'Field translation in an unavailable language ignored');
110 111 112 113 114 115 116 117 118
  }

  /**
   * Reads mysql to verify correct data is
   * written when using insert and update.
   */
  function testFieldAttachInsertAndUpdate() {
    $entity_type = 'test_entity';
    $entity = field_test_create_stub_entity(0, 0, $this->instance['bundle']);
119
    $langcode = LANGUAGE_NOT_SPECIFIED;
120 121 122 123 124 125 126 127

    // Test insert.
    $values = array();
    // Note: we try to insert one extra value ('<=' instead of '<').
    // TODO : test empty values filtering and "compression" (store consecutive deltas).
    for ($delta = 0; $delta <= $this->field['cardinality']; $delta++) {
      $values[$delta]['value'] = mt_rand(1, 127);
    }
128
    $entity->{$this->field_name}[$langcode] = $rev_values[0] = $values;
129 130 131 132 133
    field_attach_insert($entity_type, $entity);

    $rows = db_select($this->table, 't')->fields('t')->execute()->fetchAllAssoc('delta', PDO::FETCH_ASSOC);
    foreach ($values as $delta => $value) {
      if ($delta < $this->field['cardinality']) {
134
        $this->assertEqual($rows[$delta][$this->field_name . '_value'], $value['value'], t("Value $delta is inserted correctly"));
135 136 137 138 139 140 141 142 143 144 145 146 147
      }
      else {
        $this->assertFalse(array_key_exists($delta, $rows), "No extraneous value gets inserted.");
      }
    }

    // Test update.
    $entity = field_test_create_stub_entity(0, 1, $this->instance['bundle']);
    $values = array();
    // Note: we try to update one extra value ('<=' instead of '<').
    for ($delta = 0; $delta <= $this->field['cardinality']; $delta++) {
      $values[$delta]['value'] = mt_rand(1, 127);
    }
148
    $entity->{$this->field_name}[$langcode] = $rev_values[1] = $values;
149 150 151 152
    field_attach_update($entity_type, $entity);
    $rows = db_select($this->table, 't')->fields('t')->execute()->fetchAllAssoc('delta', PDO::FETCH_ASSOC);
    foreach ($values as $delta => $value) {
      if ($delta < $this->field['cardinality']) {
153
        $this->assertEqual($rows[$delta][$this->field_name . '_value'], $value['value'], t("Value $delta is updated correctly"));
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
      }
      else {
        $this->assertFalse(array_key_exists($delta, $rows), "No extraneous value gets updated.");
      }
    }

    // Check that data for both revisions are in the revision table.
    // We make sure each value is stored correctly, then unset it.
    // When an entire revision's values are unset (remembering that we
    // put one extra value in $values per revision), unset the entire
    // revision. Then, if $rev_values is empty at the end, all
    // revision data was found.
    $results = db_select($this->revision_table, 't')->fields('t')->execute();
    foreach ($results as $row) {
      $this->assertEqual($row->{$this->field_name . '_value'}, $rev_values[$row->revision_id][$row->delta]['value'], "Value {$row->delta} for revision {$row->revision_id} stored correctly");
      unset($rev_values[$row->revision_id][$row->delta]);
      if (count($rev_values[$row->revision_id]) == 1) {
        unset($rev_values[$row->revision_id]);
      }
    }
    $this->assertTrue(empty($rev_values), "All values for all revisions are stored in revision table {$this->revision_table}");

176
    // Check that update leaves the field data untouched if
177
    // $entity->{$field_name} is absent.
178
    unset($entity->{$this->field_name});
179 180 181 182
    field_attach_update($entity_type, $entity);
    $rows = db_select($this->table, 't')->fields('t')->execute()->fetchAllAssoc('delta', PDO::FETCH_ASSOC);
    foreach ($values as $delta => $value) {
      if ($delta < $this->field['cardinality']) {
183
        $this->assertEqual($rows[$delta][$this->field_name . '_value'], $value['value'], t("Update with no field_name entry leaves value $delta untouched"));
184 185 186
      }
    }

187
    // Check that update with an empty $entity->$field_name empties the field.
188
    $entity->{$this->field_name} = NULL;
189 190
    field_attach_update($entity_type, $entity);
    $rows = db_select($this->table, 't')->fields('t')->execute()->fetchAllAssoc('delta', PDO::FETCH_ASSOC);
191
    $this->assertEqual(count($rows), 0, t("Update with an empty field_name entry empties the field."));
192 193 194 195 196 197 198 199
  }

  /**
   * Tests insert and update with missing or NULL fields.
   */
  function testFieldAttachSaveMissingData() {
    $entity_type = 'test_entity';
    $entity = field_test_create_stub_entity(0, 0, $this->instance['bundle']);
200
    $langcode = LANGUAGE_NOT_SPECIFIED;
201 202 203

    // Insert: Field is missing
    field_attach_insert($entity_type, $entity);
204 205 206 207
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
208 209 210
    $this->assertEqual($count, 0, 'Missing field results in no inserts');

    // Insert: Field is NULL
211
    $entity->{$this->field_name} = NULL;
212
    field_attach_insert($entity_type, $entity);
213 214 215 216
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
217 218 219
    $this->assertEqual($count, 0, 'NULL field results in no inserts');

    // Add some real data
220
    $entity->{$this->field_name}[$langcode] = array(0 => array('value' => 1));
221
    field_attach_insert($entity_type, $entity);
222 223 224 225
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
226 227 228 229 230
    $this->assertEqual($count, 1, 'Field data saved');

    // Update: Field is missing. Data should survive.
    unset($entity->{$this->field_name});
    field_attach_update($entity_type, $entity);
231 232 233 234
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
235 236 237 238 239
    $this->assertEqual($count, 1, 'Missing field leaves data in table');

    // Update: Field is NULL. Data should be wiped.
    $entity->{$this->field_name} = NULL;
    field_attach_update($entity_type, $entity);
240 241 242 243
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
244
    $this->assertEqual($count, 0, 'NULL field leaves no data in table');
245 246

    // Add a translation in an unavailable language.
247
    $unavailable_langcode = 'xx';
248
    db_insert($this->table)
249 250
      ->fields(array('entity_type', 'bundle', 'deleted', 'entity_id', 'revision_id', 'delta', 'langcode'))
      ->values(array($entity_type, $this->instance['bundle'], 0, 0, 0, 0, $unavailable_langcode))
251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
      ->execute();
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
    $this->assertEqual($count, 1, 'Field translation in an unavailable language saved.');

    // Again add some real data.
    $entity->{$this->field_name}[$langcode] = array(0 => array('value' => 1));
    field_attach_insert($entity_type, $entity);
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
    $this->assertEqual($count, 2, 'Field data saved.');

    // Update: Field translation is missing but field is not empty. Translation
    // data should survive.
269
    $entity->{$this->field_name}[$unavailable_langcode] = array(mt_rand(1, 127));
270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
    unset($entity->{$this->field_name}[$langcode]);
    field_attach_update($entity_type, $entity);
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
    $this->assertEqual($count, 2, 'Missing field translation leaves data in table.');

    // Update: Field translation is NULL but field is not empty. Translation
    // data should be wiped.
    $entity->{$this->field_name}[$langcode] = NULL;
    field_attach_update($entity_type, $entity);
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
    $this->assertEqual($count, 1, 'NULL field translation is wiped.');
287
  }
288

289 290 291 292 293 294 295
  /**
   * Test trying to update a field with data.
   */
  function testUpdateFieldSchemaWithData() {
    // Create a decimal 5.2 field and add some data.
    $field = array('field_name' => 'decimal52', 'type' => 'number_decimal', 'settings' => array('precision' => 5, 'scale' => 2));
    $field = field_create_field($field);
296
    $instance = array('field_name' => 'decimal52', 'entity_type' => 'test_entity', 'bundle' => 'test_bundle');
297 298
    $instance = field_create_instance($instance);
    $entity = field_test_create_stub_entity(0, 0, $instance['bundle']);
299
    $entity->decimal52[LANGUAGE_NOT_SPECIFIED][0]['value'] = '1.235';
300 301 302 303 304 305
    field_attach_insert('test_entity', $entity);

    // Attempt to update the field in a way that would work without data.
    $field['settings']['scale'] = 3;
    try {
      field_update_field($field);
306
      $this->fail(t('Cannot update field schema with data.'));
307 308
    }
    catch (FieldException $e) {
309
      $this->pass(t('Cannot update field schema with data.'));
310 311
    }
  }
312

313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337
  /**
   * Test that failure to create fields is handled gracefully.
   */
  function testFieldUpdateFailure() {
    // Create a text field.
    $field = array('field_name' => 'test_text', 'type' => 'text', 'settings' => array('max_length' => 255));
    $field = field_create_field($field);

    // Attempt to update the field in a way that would break the storage.
    $prior_field = $field;
    $field['settings']['max_length'] = -1;
    try {
      field_update_field($field);
      $this->fail(t('Update succeeded.'));
    }
    catch (Exception $e) {
      $this->pass(t('Update properly failed.'));
    }

    // Ensure that the field tables are still there.
    foreach (_field_sql_storage_schema($prior_field) as $table_name => $table_info) {
      $this->assertTrue(db_table_exists($table_name), t('Table %table exists.', array('%table' => $table_name)));
    }
  }

338 339 340 341 342
  /**
   * Test adding and removing indexes while data is present.
   */
  function testFieldUpdateIndexesWithData() {

343 344 345 346
    // Create a decimal field.
    $field_name = 'testfield';
    $field = array('field_name' => $field_name, 'type' => 'text');
    $field = field_create_field($field);
347
    $instance = array('field_name' => $field_name, 'entity_type' => 'test_entity', 'bundle' => 'test_bundle');
348 349
    $instance = field_create_instance($instance);
    $tables = array(_field_sql_storage_tablename($field), _field_sql_storage_revision_tablename($field));
350

351 352
    // Verify the indexes we will create do not exist yet.
    foreach ($tables as $table) {
353 354
      $this->assertFalse(Database::getConnection()->schema()->indexExists($table, 'value'), t("No index named value exists in $table"));
      $this->assertFalse(Database::getConnection()->schema()->indexExists($table, 'value_format'), t("No index named value_format exists in $table"));
355
    }
356

357 358
    // Add data so the table cannot be dropped.
    $entity = field_test_create_stub_entity(0, 0, $instance['bundle']);
359
    $entity->{$field_name}[LANGUAGE_NOT_SPECIFIED][0]['value'] = 'field data';
360 361 362 363 364 365
    field_attach_insert('test_entity', $entity);

    // Add an index
    $field = array('field_name' => $field_name, 'indexes' => array('value' => array('value')));
    field_update_field($field);
    foreach ($tables as $table) {
366
      $this->assertTrue(Database::getConnection()->schema()->indexExists($table, "{$field_name}_value"), t("Index on value created in $table"));
367
    }
368

369 370 371 372
    // Add a different index, removing the existing custom one.
    $field = array('field_name' => $field_name, 'indexes' => array('value_format' => array('value', 'format')));
    field_update_field($field);
    foreach ($tables as $table) {
373 374
      $this->assertTrue(Database::getConnection()->schema()->indexExists($table, "{$field_name}_value_format"), t("Index on value_format created in $table"));
      $this->assertFalse(Database::getConnection()->schema()->indexExists($table, "{$field_name}_value"), t("Index on value removed in $table"));
375
    }
376 377 378 379

    // Verify that the tables were not dropped.
    $entity = field_test_create_stub_entity(0, 0, $instance['bundle']);
    field_attach_load('test_entity', array(0 => $entity));
380
    $this->assertEqual($entity->{$field_name}[LANGUAGE_NOT_SPECIFIED][0]['value'], 'field data', t("Index changes performed without dropping the tables"));
381
  }
382

383 384 385 386 387 388 389 390 391
  /**
   * Test the storage details.
   */
  function testFieldStorageDetails() {
    $current = _field_sql_storage_tablename($this->field);
    $revision = _field_sql_storage_revision_tablename($this->field);

    // Retrieve the field and instance with field_info so the storage details are attached.
    $field = field_info_field($this->field['field_name']);
392
    $instance = field_info_instance($this->instance['entity_type'], $this->instance['field_name'], $this->instance['bundle']);
393 394

    // The storage details are indexed by a storage engine type.
395
    $this->assertTrue(array_key_exists('sql', $field['storage']['details']), t('The storage type is SQL.'));
396 397

    // The SQL details are indexed by table name.
398
    $details = $field['storage']['details']['sql'];
399 400
    $this->assertTrue(array_key_exists($current, $details[FIELD_LOAD_CURRENT]), t('Table name is available in the instance array.'));
    $this->assertTrue(array_key_exists($revision, $details[FIELD_LOAD_REVISION]), t('Revision table name is available in the instance array.'));
401 402 403 404 405

    // Test current and revision storage details together because the columns
    // are the same.
    foreach ((array) $this->field['columns'] as $column_name => $attributes) {
      $storage_column_name = _field_sql_storage_columnname($this->field['field_name'], $column_name);
406 407
      $this->assertEqual($details[FIELD_LOAD_CURRENT][$current][$column_name], $storage_column_name, t('Column name %value matches the definition in %bin.', array('%value' => $column_name, '%bin' => $current)));
      $this->assertEqual($details[FIELD_LOAD_REVISION][$revision][$column_name], $storage_column_name, t('Column name %value matches the definition in %bin.', array('%value' => $column_name, '%bin' => $revision)));
408 409
    }
  }
410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431

  /**
   * Test foreign key support.
   */
  function testFieldSqlStorageForeignKeys() {
    // Create a decimal field.
    $field_name = 'testfield';
    $field = array('field_name' => $field_name, 'type' => 'text');
    $field = field_create_field($field);
    // Retrieve the field and instance with field_info and verify the foreign
    // keys are in place.
    $field = field_info_field($field_name);
    $this->assertEqual($field['foreign keys']['format']['table'], 'filter_format', t('Foreign key table name preserved through CRUD'));
    $this->assertEqual($field['foreign keys']['format']['columns']['format'], 'format', t('Foreign key column name preserved through CRUD'));
    // Now grab the SQL schema and verify that too.
    $schema = drupal_get_schema(_field_sql_storage_tablename($field));
    $this->assertEqual(count($schema['foreign keys']), 1, t("There is 1 foreign key in the schema"));
    $foreign_key = reset($schema['foreign keys']);
    $filter_column = _field_sql_storage_columnname($field['field_name'], 'format');
    $this->assertEqual($foreign_key['table'], 'filter_format', t('Foreign key table name preserved in the schema'));
    $this->assertEqual($foreign_key['columns'][$filter_column], 'format', t('Foreign key column name preserved in the schema'));
  }
Dries's avatar
 
Dries committed
432
}