<?php

/**

 * Dummy class for fetching into a class.

 *

 * PDO supports using a new instance of an arbitrary class for records

 * rather than just a stdClass or array. This class is for testing that

 * functionality. (See testQueryFetchClass() below)

 */

class FakeRecord { }

/**

 * Base test class for databases.

 *

 * Because all database tests share the same test data, we can centralize that

 * here.

 */

class DatabaseTestCase extends DrupalWebTestCase {

  protected $profile = 'testing';

  function setUp() {

    parent::setUp('database_test');

    $schema['test'] = drupal_get_schema('test');

    $schema['test_people'] = drupal_get_schema('test_people');

    $schema['test_people_copy'] = drupal_get_schema('test_people_copy');

    $schema['test_one_blob'] = drupal_get_schema('test_one_blob');

    $schema['test_two_blobs'] = drupal_get_schema('test_two_blobs');

    $schema['test_task'] = drupal_get_schema('test_task');

    $this->installTables($schema);

    $this->addSampleData();

  }

  /**

   * Set up several tables needed by a certain test.

   *

   * @param $schema

   *   An array of table definitions to install.

   */

  function installTables($schema) {

    // This ends up being a test for table drop and create, too, which is nice.

    foreach ($schema as $name => $data) {

      if (db_table_exists($name)) {

        db_drop_table($name);

      }

      db_create_table($name, $data);

    }

    foreach ($schema as $name => $data) {

      $this->assertTrue(db_table_exists($name), format_string('Table @name created successfully.', array('@name' => $name)));

    }

  }

  /**

   * Set up tables for NULL handling.

   */

  function ensureSampleDataNull() {

    $schema['test_null'] = drupal_get_schema('test_null');

    $this->installTables($schema);

    db_insert('test_null')

    ->fields(array('name', 'age'))

    ->values(array(

      'name' => 'Kermit',

      'age' => 25,

    ))

    ->values(array(

      'name' => 'Fozzie',

      'age' => NULL,

    ))

    ->values(array(

      'name' => 'Gonzo',

      'age' => 27,

    ))

    ->execute();

  }

  /**

   * Setup our sample data.

   *

   * These are added using db_query(), since we're not trying to test the

   * INSERT operations here, just populate.

   */

  function addSampleData() {

    // We need the IDs, so we can't use a multi-insert here.

    $john = db_insert('test')

      ->fields(array(

        'name' => 'John',

        'age' => 25,

        'job' => 'Singer',

      ))

      ->execute();

    $george = db_insert('test')

      ->fields(array(

        'name' => 'George',

        'age' => 27,

        'job' => 'Singer',

      ))

      ->execute();

    $ringo = db_insert('test')

      ->fields(array(

        'name' => 'Ringo',

        'age' => 28,

        'job' => 'Drummer',

      ))

      ->execute();

    $paul = db_insert('test')

      ->fields(array(

        'name' => 'Paul',

        'age' => 26,

        'job' => 'Songwriter',

      ))

      ->execute();

    db_insert('test_people')

      ->fields(array(

        'name' => 'Meredith',

        'age' => 30,

        'job' => 'Speaker',

      ))

      ->execute();

    db_insert('test_task')

      ->fields(array('pid', 'task', 'priority'))

      ->values(array(

        'pid' => $john,

        'task' => 'eat',

        'priority' => 3,

      ))

      ->values(array(

        'pid' => $john,

        'task' => 'sleep',

        'priority' => 4,

      ))

      ->values(array(

        'pid' => $john,

        'task' => 'code',

        'priority' => 1,

      ))

      ->values(array(

        'pid' => $george,

        'task' => 'sing',

        'priority' => 2,

      ))

      ->values(array(

        'pid' => $george,

        'task' => 'sleep',

        'priority' => 2,

      ))

      ->values(array(

        'pid' => $paul,

        'task' => 'found new band',

        'priority' => 1,

      ))

      ->values(array(

        'pid' => $paul,

        'task' => 'perform at superbowl',

        'priority' => 3,

      ))

      ->execute();

  }

}

/**

 * Test connection management.

 */

class DatabaseConnectionTestCase extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Connection tests',

      'description' => 'Tests of the core database system.',

      'group' => 'Database',

    );

  }

  /**

   * Test that connections return appropriate connection objects.

   */

  function testConnectionRouting() {

    // Clone the master credentials to a slave connection.

    // Note this will result in two independent connection objects that happen

    // to point to the same place.

    $connection_info = Database::getConnectionInfo('default');

    Database::addConnectionInfo('default', 'slave', $connection_info['default']);

    $db1 = Database::getConnection('default', 'default');

    $db2 = Database::getConnection('slave', 'default');

    $this->assertNotNull($db1, 'default connection is a real connection object.');

    $this->assertNotNull($db2, 'slave connection is a real connection object.');

    $this->assertNotIdentical($db1, $db2, 'Each target refers to a different connection.');

    // Try to open those targets another time, that should return the same objects.

    $db1b = Database::getConnection('default', 'default');

    $db2b = Database::getConnection('slave', 'default');

    $this->assertIdentical($db1, $db1b, 'A second call to getConnection() returns the same object.');

    $this->assertIdentical($db2, $db2b, 'A second call to getConnection() returns the same object.');

    // Try to open an unknown target.

    $unknown_target = $this->randomName();

    $db3 = Database::getConnection($unknown_target, 'default');

    $this->assertNotNull($db3, 'Opening an unknown target returns a real connection object.');

    $this->assertIdentical($db1, $db3, 'An unknown target opens the default connection.');

    // Try to open that unknown target another time, that should return the same object.

    $db3b = Database::getConnection($unknown_target, 'default');

    $this->assertIdentical($db3, $db3b, 'A second call to getConnection() returns the same object.');

  }

  /**

   * Test that connections return appropriate connection objects.

   */

  function testConnectionRoutingOverride() {

    // Clone the master credentials to a slave connection.

    // Note this will result in two independent connection objects that happen

    // to point to the same place.

    $connection_info = Database::getConnectionInfo('default');

    Database::addConnectionInfo('default', 'slave', $connection_info['default']);

    Database::ignoreTarget('default', 'slave');

    $db1 = Database::getConnection('default', 'default');

    $db2 = Database::getConnection('slave', 'default');

    $this->assertIdentical($db1, $db2, 'Both targets refer to the same connection.');

  }

  /**

   * Tests the closing of a database connection.

   */

  function testConnectionClosing() {

    // Open the default target so we have an object to compare.

    $db1 = Database::getConnection('default', 'default');

    // Try to close the default connection, then open a new one.

    Database::closeConnection('default', 'default');

    $db2 = Database::getConnection('default', 'default');

    // Opening a connection after closing it should yield an object different than the original.

    $this->assertNotIdentical($db1, $db2, 'Opening the default connection after it is closed returns a new object.');

  }

  /**

   * Tests the connection options of the active database.

   */

  function testConnectionOptions() {

    $connection_info = Database::getConnectionInfo('default');

    // Be sure we're connected to the default database.

    $db = Database::getConnection('default', 'default');

    $connectionOptions = $db->getConnectionOptions();

    // In the MySQL driver, the port can be different, so check individual

    // options.

    $this->assertEqual($connection_info['default']['driver'], $connectionOptions['driver'], 'The default connection info driver matches the current connection options driver.');

    $this->assertEqual($connection_info['default']['database'], $connectionOptions['database'], 'The default connection info database matches the current connection options database.');

    // Set up identical slave and confirm connection options are identical.

    Database::addConnectionInfo('default', 'slave', $connection_info['default']);

    $db2 = Database::getConnection('slave', 'default');

    $connectionOptions2 = $db2->getConnectionOptions();

    // Get a fresh copy of the default connection options.

    $connectionOptions = $db->getConnectionOptions();

    $this->assertIdentical($connectionOptions, $connectionOptions2, 'The default and slave connection options are identical.');

    // Set up a new connection with different connection info.

    $test = $connection_info['default'];

    $test['database'] .= 'test';

    Database::addConnectionInfo('test', 'default', $test);

    $connection_info = Database::getConnectionInfo('test');

    // Get a fresh copy of the default connection options.

    $connectionOptions = $db->getConnectionOptions();

    $this->assertNotEqual($connection_info['default']['database'], $connectionOptions['database'], 'The test connection info database does not match the current connection options database.');

  }

}

/**

 * Test cloning Select queries.

 */

class DatabaseSelectCloneTest extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Select tests, cloning',

      'description' => 'Test cloning Select queries.',

      'group' => 'Database',

    );

  }

  /**

   * Test that subqueries as value within conditions are cloned properly.

   */

  function testSelectConditionSubQueryCloning() {

    $subquery = db_select('test', 't');

    $subquery->addField('t', 'id', 'id');

    $subquery->condition('age', 28, '<');

    $query = db_select('test', 't');

    $query->addField('t', 'name', 'name');

    $query->condition('id', $subquery, 'IN');

    $clone = clone $query;

    // Cloned query should not be altered by the following modification

    // happening on original query.

    $subquery->condition('age', 25, '>');

    $clone_result = $clone->countQuery()->execute()->fetchField();

    $query_result = $query->countQuery()->execute()->fetchField();

    // Make sure the cloned query has not been modified

    $this->assertEqual(3, $clone_result, 'The cloned query returns the expected number of rows');

    $this->assertEqual(2, $query_result, 'The query returns the expected number of rows');

  }

}

/**

 * Test fetch actions, part 1.

 *

 * We get timeout errors if we try to run too many tests at once.

 */

class DatabaseFetchTestCase extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Fetch tests',

      'description' => 'Test the Database system\'s various fetch capabilities.',

      'group' => 'Database',

    );

  }

  /**

   * Confirm that we can fetch a record properly in default object mode.

   */

  function testQueryFetchDefault() {

    $records = array();

    $result = db_query('SELECT name FROM {test} WHERE age = :age', array(':age' => 25));

    $this->assertTrue($result instanceof DatabaseStatementInterface, 'Result set is a Drupal statement object.');

    foreach ($result as $record) {

      $records[] = $record;

      $this->assertTrue(is_object($record), 'Record is an object.');

      $this->assertIdentical($record->name, 'John', '25 year old is John.');

    }

    $this->assertIdentical(count($records), 1, 'There is only one record.');

  }

  /**

   * Confirm that we can fetch a record to an object explicitly.

   */

  function testQueryFetchObject() {

    $records = array();

    $result = db_query('SELECT name FROM {test} WHERE age = :age', array(':age' => 25), array('fetch' => PDO::FETCH_OBJ));

    foreach ($result as $record) {

      $records[] = $record;

      $this->assertTrue(is_object($record), 'Record is an object.');

      $this->assertIdentical($record->name, 'John', '25 year old is John.');

    }

    $this->assertIdentical(count($records), 1, 'There is only one record.');

  }

  /**

   * Confirm that we can fetch a record to an array associative explicitly.

   */

  function testQueryFetchArray() {

    $records = array();

    $result = db_query('SELECT name FROM {test} WHERE age = :age', array(':age' => 25), array('fetch' => PDO::FETCH_ASSOC));

    foreach ($result as $record) {

      $records[] = $record;

      if ($this->assertTrue(is_array($record), 'Record is an array.')) {

        $this->assertIdentical($record['name'], 'John', 'Record can be accessed associatively.');

      }

    }

    $this->assertIdentical(count($records), 1, 'There is only one record.');

  }

  /**

   * Confirm that we can fetch a record into a new instance of a custom class.

   *

   * @see FakeRecord

   */

  function testQueryFetchClass() {

    $records = array();

    $result = db_query('SELECT name FROM {test} WHERE age = :age', array(':age' => 25), array('fetch' => 'FakeRecord'));

    foreach ($result as $record) {

      $records[] = $record;

      if ($this->assertTrue($record instanceof FakeRecord, 'Record is an object of class FakeRecord.')) {

        $this->assertIdentical($record->name, 'John', '25 year old is John.');

      }

    }

    $this->assertIdentical(count($records), 1, 'There is only one record.');

  }

}

/**

 * Test fetch actions, part 2.

 *

 * We get timeout errors if we try to run too many tests at once.

 */

class DatabaseFetch2TestCase extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Fetch tests, part 2',

      'description' => 'Test the Database system\'s various fetch capabilities.',

      'group' => 'Database',

    );

  }

  function setUp() {

    parent::setUp();

  }

  // Confirm that we can fetch a record into an indexed array explicitly.

  function testQueryFetchNum() {

    $records = array();

    $result = db_query('SELECT name FROM {test} WHERE age = :age', array(':age' => 25), array('fetch' => PDO::FETCH_NUM));

    foreach ($result as $record) {

      $records[] = $record;

      if ($this->assertTrue(is_array($record), 'Record is an array.')) {

        $this->assertIdentical($record[0], 'John', 'Record can be accessed numerically.');

      }

    }

    $this->assertIdentical(count($records), 1, 'There is only one record');

  }

  /**

   * Confirm that we can fetch a record into a doubly-keyed array explicitly.

   */

  function testQueryFetchBoth() {

    $records = array();

    $result = db_query('SELECT name FROM {test} WHERE age = :age', array(':age' => 25), array('fetch' => PDO::FETCH_BOTH));

    foreach ($result as $record) {

      $records[] = $record;

      if ($this->assertTrue(is_array($record), 'Record is an array.')) {

        $this->assertIdentical($record[0], 'John', 'Record can be accessed numerically.');

        $this->assertIdentical($record['name'], 'John', 'Record can be accessed associatively.');

      }

    }

    $this->assertIdentical(count($records), 1, 'There is only one record.');

  }

  /**

   * Confirm that we can fetch an entire column of a result set at once.

   */

  function testQueryFetchCol() {

    $records = array();

    $result = db_query('SELECT name FROM {test} WHERE age > :age', array(':age' => 25));

    $column = $result->fetchCol();

    $this->assertIdentical(count($column), 3, 'fetchCol() returns the right number of records.');

    $result = db_query('SELECT name FROM {test} WHERE age > :age', array(':age' => 25));

    $i = 0;

    foreach ($result as $record) {

      $this->assertIdentical($record->name, $column[$i++], 'Column matches direct accesss.');

    }

  }

}

/**

 * Test the insert builder.

 */

class DatabaseInsertTestCase extends DatabaseTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Insert tests',

      'description' => 'Test the Insert query builder.',

      'group' => 'Database',

    );

  }

  /**

   * Test the very basic insert functionality.

   */

  function testSimpleInsert() {

    $num_records_before = db_query('SELECT COUNT(*) FROM {test}')->fetchField();

    $query = db_insert('test');

    $query->fields(array(

      'name' => 'Yoko',

      'age' => '29',

    ));

    $query->execute();

    $num_records_after = db_query('SELECT COUNT(*) FROM {test}')->fetchField();

    $this->assertIdentical($num_records_before + 1, (int) $num_records_after, 'Record inserts correctly.');

    $saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Yoko'))->fetchField();

    $this->assertIdentical($saved_age, '29', 'Can retrieve after inserting.');

  }

  /**

   * Test that we can insert multiple records in one query object.

   */

  function testMultiInsert() {

    $num_records_before = (int) db_query('SELECT COUNT(*) FROM {test}')->fetchField();

    $query = db_insert('test');

    $query->fields(array(

      'name' => 'Larry',

      'age' => '30',

    ));

    // We should be able to specify values in any order if named.

    $query->values(array(

      'age' => '31',

      'name' => 'Curly',

    ));

    // We should be able to say "use the field order".

    // This is not the recommended mechanism for most cases, but it should work.

    $query->values(array('Moe', '32'));

    $query->execute();

    $num_records_after = (int) db_query('SELECT COUNT(*) FROM {test}')->fetchField();

    $this->assertIdentical($num_records_before + 3, $num_records_after, 'Record inserts correctly.');

    $saved_age = db_query('SELECT age FROM {test} WHERE name = :name', array(':name' => 'Larry'))->fetchField();