Club Drupal

<?php

/**

 * @file

 * Tests for field_sql_storage.module.

 *

 * Field_sql_storage.module implements the default back-end storage plugin

 * for the Field Strage API.

 */

/**

 * Tests field storage.

 */

class FieldSqlStorageTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name'  => 'Field SQL storage tests',

      'description'  => "Test field SQL storage module.",

      'group' => 'Field API'

    );

  }

  function setUp() {

    parent::setUp('field_sql_storage', 'field', 'field_test', 'text');

    $this->field_name = strtolower($this->randomName());

    $this->field = array('field_name' => $this->field_name, 'type' => 'test_field', 'cardinality' => 4);

    $this->field = field_create_field($this->field);

    $this->instance = array(

      'field_name' => $this->field_name,

      'entity_type' => 'test_entity',

      'bundle' => 'test_bundle'

    );

    $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);

  }

  /**

   * Uses the mysql tables and records to verify

   * field_load_revision works correctly.

   */

  function testFieldAttachLoad() {

    $entity_type = 'test_entity';

    $eid = 0;

    $langcode = LANGUAGE_NONE;

    $columns = array('entity_type', 'entity_id', 'revision_id', 'delta', 'language', $this->field_name . '_value');

    // 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;

        $query->values(array($entity_type, $eid, $evid, $delta, $langcode, $value));

      }

    }

    $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) {

      $query->values(array($entity_type, $eid, 0, $delta, $langcode, $value));

    }

    $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']) {

        $this->assertEqual($entity->{$this->field_name}[$langcode][$delta]['value'], $value, "Value $delta is loaded correctly for current revision");

      }

      else {

        $this->assertFalse(array_key_exists($delta, $entity->{$this->field_name}[$langcode]), "No extraneous value gets loaded for current revision.");

      }

    }

    // 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']) {

          $this->assertEqual($entity->{$this->field_name}[$langcode][$delta]['value'], $value, "Value $delta for revision $evid is loaded correctly");

        }

        else {

          $this->assertFalse(array_key_exists($delta, $entity->{$this->field_name}[$langcode]), "No extraneous value gets loaded for revision $evid.");

        }

      }

    }

    // Add a translation in an unavailable language and verify it is not loaded.

    $eid = $evid = 1;

    $unavailable_language = 'xx';

    $entity = field_test_create_stub_entity($eid, $evid, $this->instance['bundle']);

    $values = array($entity_type, $eid, $evid, 0, $unavailable_language, mt_rand(1, 127));

    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));

    $this->assertFalse(array_key_exists($unavailable_language, $entity->{$this->field_name}), 'Field translation in an unavailable language ignored');

  }

  /**

   * 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']);

    $langcode = LANGUAGE_NONE;

    // 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);

    }

    $entity->{$this->field_name}[$langcode] = $rev_values[0] = $values;

    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']) {

        $this->assertEqual($rows[$delta][$this->field_name . '_value'], $value['value'], format_string("Value %delta is inserted correctly", array('%delta' => $delta)));

      }

      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);

    }

    $entity->{$this->field_name}[$langcode] = $rev_values[1] = $values;

    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']) {

        $this->assertEqual($rows[$delta][$this->field_name . '_value'], $value['value'], format_string("Value %delta is updated correctly", array('%delta' => $delta)));

      }

      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}");

    // Check that update leaves the field data untouched if

    // $entity->{$field_name} is absent.

    unset($entity->{$this->field_name});

    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']) {

        $this->assertEqual($rows[$delta][$this->field_name . '_value'], $value['value'], format_string("Update with no field_name entry leaves value %delta untouched", array('%delta' => $delta)));

      }

    }

    // Check that update with an empty $entity->$field_name empties the field.

    $entity->{$this->field_name} = NULL;

    field_attach_update($entity_type, $entity);

    $rows = db_select($this->table, 't')->fields('t')->execute()->fetchAllAssoc('delta', PDO::FETCH_ASSOC);

    $this->assertEqual(count($rows), 0, "Update with an empty field_name entry empties the field.");

  }

  /**

   * 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']);

    $langcode = LANGUAGE_NONE;

    // Insert: Field is missing

    field_attach_insert($entity_type, $entity);

    $count = db_select($this->table)

      ->countQuery()

      ->execute()

      ->fetchField();

    $this->assertEqual($count, 0, 'Missing field results in no inserts');

    // Insert: Field is NULL

    $entity->{$this->field_name} = NULL;

    field_attach_insert($entity_type, $entity);

    $count = db_select($this->table)

      ->countQuery()

      ->execute()

      ->fetchField();

    $this->assertEqual($count, 0, 'NULL field results in no inserts');

    // 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, 1, 'Field data saved');

    // Update: Field is missing. Data should survive.

    unset($entity->{$this->field_name});

    field_attach_update($entity_type, $entity);

    $count = db_select($this->table)

      ->countQuery()

      ->execute()

      ->fetchField();

    $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);

    $count = db_select($this->table)

      ->countQuery()

      ->execute()

      ->fetchField();

    $this->assertEqual($count, 0, 'NULL field leaves no data in table');

    // Add a translation in an unavailable language.

    $unavailable_language = 'xx';

    db_insert($this->table)

      ->fields(array('entity_type', 'bundle', 'deleted', 'entity_id', 'revision_id', 'delta', 'language'))

      ->values(array($entity_type, $this->instance['bundle'], 0, 0, 0, 0, $unavailable_language))

      ->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.

    $entity->{$this->field_name}[$unavailable_language] = array(mt_rand(1, 127));

    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.');

  }

  /**

   * 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);

    $instance = array('field_name' => 'decimal52', 'entity_type' => 'test_entity', 'bundle' => 'test_bundle');

    $instance = field_create_instance($instance);

    $entity = field_test_create_stub_entity(0, 0, $instance['bundle']);

    $entity->decimal52[LANGUAGE_NONE][0]['value'] = '1.235';

    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);

      $this->fail(t('Cannot update field schema with data.'));

    }

    catch (FieldException $e) {

      $this->pass(t('Cannot update field schema with data.'));

    }

  }

  /**

   * 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. The

    // parenthesis suffix is needed because SQLite has *very* relaxed rules for

    // data types, so we actually need to provide an invalid SQL syntax in order

    // to break it.

    // @see https://www.sqlite.org/datatype3.html

    $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), format_string('Table %table exists.', array('%table' => $table_name)));

    }

  }

  /**

   * Test adding and removing indexes while data is present.

   */

  function testFieldUpdateIndexesWithData() {

    // Create a decimal field.

    $field_name = 'testfield';

    $field = array('field_name' => $field_name, 'type' => 'text');

    $field = field_create_field($field);

    $instance = array('field_name' => $field_name, 'entity_type' => 'test_entity', 'bundle' => 'test_bundle');

    $instance = field_create_instance($instance);

    $tables = array(_field_sql_storage_tablename($field), _field_sql_storage_revision_tablename($field));

    // Verify the indexes we will create do not exist yet.

    foreach ($tables as $table) {

      $this->assertFalse(Database::getConnection()->schema()->indexExists($table, 'value'), format_string("No index named value exists in %table", array('%table' => $table)));

      $this->assertFalse(Database::getConnection()->schema()->indexExists($table, 'value_format'), format_string("No index named value_format exists in %table", array('%table' => $table)));

    }

    // Add data so the table cannot be dropped.

    $entity = field_test_create_stub_entity(0, 0, $instance['bundle']);

    $entity->{$field_name}[LANGUAGE_NONE][0]['value'] = 'field data';

    field_attach_insert('test_entity', $entity);

    // Add an index

    $field = array('field_name' => $field_name, 'indexes' => array('value' => array(array('value', 255))));

    field_update_field($field);

    foreach ($tables as $table) {

      $this->assertTrue(Database::getConnection()->schema()->indexExists($table, "{$field_name}_value"), format_string("Index on value created in %table", array('%table' => $table)));

    }

    // Add a different index, removing the existing custom one.

    $field = array('field_name' => $field_name, 'indexes' => array('value_format' => array(array('value', 127), array('format', 127))));

    field_update_field($field);

    foreach ($tables as $table) {

      $this->assertTrue(Database::getConnection()->schema()->indexExists($table, "{$field_name}_value_format"), format_string("Index on value_format created in %table", array('%table' => $table)));

      $this->assertFalse(Database::getConnection()->schema()->indexExists($table, "{$field_name}_value"), format_string("Index on value removed in %table", array('%table' => $table)));

    }

    // 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));

    $this->assertEqual($entity->{$field_name}[LANGUAGE_NONE][0]['value'], 'field data', "Index changes performed without dropping the tables");

  }

  /**

   * 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']);

    $instance = field_info_instance($this->instance['entity_type'], $this->instance['field_name'], $this->instance['bundle']);

    // The storage details are indexed by a storage engine type.

    $this->assertTrue(array_key_exists('sql', $field['storage']['details']), 'The storage type is SQL.');

    // The SQL details are indexed by table name.

    $details = $field['storage']['details']['sql'];

    $this->assertTrue(array_key_exists($current, $details[FIELD_LOAD_CURRENT]), 'Table name is available in the instance array.');

    $this->assertTrue(array_key_exists($revision, $details[FIELD_LOAD_REVISION]), 'Revision table name is available in the instance array.');

    // 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);

      $this->assertEqual($details[FIELD_LOAD_CURRENT][$current][$column_name], $storage_column_name, format_string('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, format_string('Column name %value matches the definition in %bin.', array('%value' => $column_name, '%bin' => $revision)));

    }

  }

  /**

   * Test foreign key support.

   */

  function testFieldSqlStorageForeignKeys() {

    // Create a 'shape' field, with a configurable foreign key (see

    // field_test_field_schema()).

    $field_name = 'testfield';

    $foreign_key_name = 'shape';

    $field = array('field_name' => $field_name, 'type' => 'shape', 'settings' => array('foreign_key_name' => $foreign_key_name));

    field_create_field($field);

    // Retrieve the field definition and check that the foreign key is in place.

    $field = field_info_field($field_name);

    $this->assertEqual($field['foreign keys'][$foreign_key_name]['table'], $foreign_key_name, 'Foreign key table name preserved through CRUD');

    $this->assertEqual($field['foreign keys'][$foreign_key_name]['columns'][$foreign_key_name], 'id', 'Foreign key column name preserved through CRUD');

    // Update the field settings, it should update the foreign key definition

    // too.

    $foreign_key_name = 'color';

    $field['settings']['foreign_key_name'] = $foreign_key_name;

    field_update_field($field);

    // Retrieve the field definition and check that the foreign key is in place.

    $field = field_info_field($field_name);

    $this->assertEqual($field['foreign keys'][$foreign_key_name]['table'], $foreign_key_name, 'Foreign key table name modified after update');

    $this->assertEqual($field['foreign keys'][$foreign_key_name]['columns'][$foreign_key_name], 'id', 'Foreign key column name modified after update');

    // Now grab the SQL schema and verify that too.

    $schema = drupal_get_schema(_field_sql_storage_tablename($field), TRUE);

    $this->assertEqual(count($schema['foreign keys']), 1, 'There is 1 foreign key in the schema');

    $foreign_key = reset($schema['foreign keys']);

    $foreign_key_column = _field_sql_storage_columnname($field['field_name'], $foreign_key_name);

    $this->assertEqual($foreign_key['table'], $foreign_key_name, 'Foreign key table name preserved in the schema');

    $this->assertEqual($foreign_key['columns'][$foreign_key_column], 'id', 'Foreign key column name preserved in the schema');

  }

  /**

   * Test handling multiple conditions on one column of a field.

   *

   * Tests both the result and the complexity of the query.

   */

  function testFieldSqlStorageMultipleConditionsSameColumn() {

    $entity = field_test_create_stub_entity(NULL, NULL);

    $entity->{$this->field_name}[LANGUAGE_NONE][0] = array('value' => 1);

    field_test_entity_save($entity);

    $entity = field_test_create_stub_entity(NULL, NULL);

    $entity->{$this->field_name}[LANGUAGE_NONE][0] = array('value' => 2);

    field_test_entity_save($entity);

    $entity = field_test_create_stub_entity(NULL, NULL);

    $entity->{$this->field_name}[LANGUAGE_NONE][0] = array('value' => 3);

    field_test_entity_save($entity);

    $query = new EntityFieldQuery();

    // This tag causes field_test_query_store_global_test_query_alter() to be

    // invoked so that the query can be tested.

    $query->addTag('store_global_test_query');

    $query->entityCondition('entity_type', 'test_entity');

    $query->entityCondition('bundle', 'test_bundle');

    $query->fieldCondition($this->field_name, 'value', 1, '<>', 0, LANGUAGE_NONE);

    $query->fieldCondition($this->field_name, 'value', 2, '<>', 0, LANGUAGE_NONE);

    $result = field_sql_storage_field_storage_query($query);

    // Test the results.

    $this->assertEqual(1, count($result), format_string('One result should be returned, got @count', array('@count' => count($result))));

    // Test the complexity of the query.

    $query = $GLOBALS['test_query'];

    $this->assertNotNull($query, 'Precondition: the query should be available');

    $tables = $query->getTables();

    $this->assertEqual(1, count($tables), 'The query contains just one table.');

    // Clean up.

    unset($GLOBALS['test_query']);

  }

  /**

   * Test handling multiple conditions on multiple columns of one field.

   *

   * Tests both the result and the complexity of the query.

   */

  function testFieldSqlStorageMultipleConditionsDifferentColumns() {

    // Create the multi-column shape field

    $field_name = strtolower($this->randomName());

    $field = array('field_name' => $field_name, 'type' => 'shape', 'cardinality' => 4);

    $field = field_create_field($field);

    $instance = array(

      'field_name' => $field_name,

      'entity_type' => 'test_entity',

      'bundle' => 'test_bundle'

    );

    $instance = field_create_instance($instance);

    $entity = field_test_create_stub_entity(NULL, NULL);

    $entity->{$field_name}[LANGUAGE_NONE][0] = array('shape' => 'A', 'color' => 'X');

    field_test_entity_save($entity);

    $entity = field_test_create_stub_entity(NULL, NULL);

    $entity->{$field_name}[LANGUAGE_NONE][0] = array('shape' => 'B', 'color' => 'X');

    field_test_entity_save($entity);

    $entity = field_test_create_stub_entity(NULL, NULL);

    $entity->{$field_name}[LANGUAGE_NONE][0] = array('shape' => 'A', 'color' => 'Y');

    field_test_entity_save($entity);

    $query = new EntityFieldQuery();

    // This tag causes field_test_query_store_global_test_query_alter() to be

    // invoked so that the query can be tested.

    $query->addTag('store_global_test_query');

    $query->entityCondition('entity_type', 'test_entity');

    $query->entityCondition('bundle', 'test_bundle');

    $query->fieldCondition($field_name, 'shape', 'B', '=', 'something', LANGUAGE_NONE);

    $query->fieldCondition($field_name, 'color', 'X', '=', 'something', LANGUAGE_NONE);

    $result = field_sql_storage_field_storage_query($query);

    // Test the results.

    $this->assertEqual(1, count($result), format_string('One result should be returned, got @count', array('@count' => count($result))));

    // Test the complexity of the query.

    $query = $GLOBALS['test_query'];

    $this->assertNotNull($query, 'Precondition: the query should be available');

    $tables = $query->getTables();

    $this->assertEqual(1, count($tables), 'The query contains just one table.');

    // Clean up.

    unset($GLOBALS['test_query']);

  }

  /**

   * Test handling multiple conditions on multiple columns of one field for multiple languages.

   *

   * Tests both the result and the complexity of the query.

   */

  function testFieldSqlStorageMultipleConditionsDifferentColumnsMultipleLanguages() {

    field_test_entity_info_translatable('test_entity', TRUE);

    // Create the multi-column shape field

    $field_name = strtolower($this->randomName());

    $field = array('field_name' => $field_name, 'type' => 'shape', 'cardinality' => 4, 'translatable' => TRUE);

    $field = field_create_field($field);

    $instance = array(

      'field_name' => $field_name,

      'entity_type' => 'test_entity',

      'bundle' => 'test_bundle',

      'settings' => array(

        // Prevent warning from field_test_field_load().

        'test_hook_field_load' => FALSE,

      ),

    );

    $instance = field_create_instance($instance);

    $entity = field_test_create_stub_entity(NULL, NULL);

    $entity->{$field_name}[LANGUAGE_NONE][0] = array('shape' => 'A', 'color' => 'X');

    $entity->{$field_name}['en'][0] = array('shape' => 'B', 'color' => 'Y');

    field_test_entity_save($entity);

    $entity = field_test_entity_test_load($entity->ftid);

    $query = new EntityFieldQuery();

    // This tag causes field_test_query_store_global_test_query_alter() to be

    // invoked so that the query can be tested.

    $query->addTag('store_global_test_query');

    $query->entityCondition('entity_type', 'test_entity');

    $query->entityCondition('bundle', 'test_bundle');

    $query->fieldCondition($field_name, 'color', 'X', '=', NULL, LANGUAGE_NONE);

    $query->fieldCondition($field_name, 'shape', 'B', '=', NULL, 'en');

    $result = field_sql_storage_field_storage_query($query);

    // Test the results.

    $this->assertEqual(1, count($result), format_string('One result should be returned, got @count', array('@count' => count($result))));

    // Test the complexity of the query.

    $query = $GLOBALS['test_query'];

    $this->assertNotNull($query, 'Precondition: the query should be available');

    $tables = $query->getTables();

    $this->assertEqual(2, count($tables), 'The query contains two tables.');

    // Clean up.

    unset($GLOBALS['test_query']);

  }

}