Tests the SELECT builder.
Expanded class hierarchy of SelectTest
class SelectTest extends DatabaseTestBase {
public static function getInfo() {
return array(
'name' => 'Select tests',
'description' => 'Test the Select query builder.',
'group' => 'Database',
);
}
/**
* Tests rudimentary SELECT statements.
*/
function testSimpleSelect() {
$query = db_select('test');
$name_field = $query
->addField('test', 'name');
$age_field = $query
->addField('test', 'age', 'age');
$result = $query
->execute();
$num_records = 0;
foreach ($result as $record) {
$num_records++;
}
$this
->assertEqual($num_records, 4, 'Returned the correct number of rows.');
}
/**
* Tests rudimentary SELECT statement with a COMMENT.
*/
function testSimpleComment() {
$query = db_select('test')
->comment('Testing query comments');
$name_field = $query
->addField('test', 'name');
$age_field = $query
->addField('test', 'age', 'age');
$result = $query
->execute();
$num_records = 0;
foreach ($result as $record) {
$num_records++;
}
$query = (string) $query;
$expected = "/* Testing query comments */ SELECT test.name AS name, test.age AS age\nFROM \n{test} test";
$this
->assertEqual($num_records, 4, 'Returned the correct number of rows.');
$this
->assertEqual($query, $expected, 'The flattened query contains the comment string.');
}
/**
* Tests query COMMENT system against vulnerabilities.
*/
function testVulnerableComment() {
$query = db_select('test')
->comment('Testing query comments */ SELECT nid FROM {node}; --');
$name_field = $query
->addField('test', 'name');
$age_field = $query
->addField('test', 'age', 'age');
$result = $query
->execute();
$num_records = 0;
foreach ($result as $record) {
$num_records++;
}
$query = (string) $query;
$expected = "/* Testing query comments SELECT nid FROM {node}; -- */ SELECT test.name AS name, test.age AS age\nFROM \n{test} test";
$this
->assertEqual($num_records, 4, 'Returned the correct number of rows.');
$this
->assertEqual($query, $expected, 'The flattened query contains the sanitised comment string.');
}
/**
* Tests basic conditionals on SELECT statements.
*/
function testSimpleSelectConditional() {
$query = db_select('test');
$name_field = $query
->addField('test', 'name');
$age_field = $query
->addField('test', 'age', 'age');
$query
->condition('age', 27);
$result = $query
->execute();
// Check that the aliases are being created the way we want.
$this
->assertEqual($name_field, 'name', 'Name field alias is correct.');
$this
->assertEqual($age_field, 'age', 'Age field alias is correct.');
// Ensure that we got the right record.
$record = $result
->fetch();
$this
->assertEqual($record->{$name_field}, 'George', 'Fetched name is correct.');
$this
->assertEqual($record->{$age_field}, 27, 'Fetched age is correct.');
}
/**
* Tests SELECT statements with expressions.
*/
function testSimpleSelectExpression() {
$query = db_select('test');
$name_field = $query
->addField('test', 'name');
$age_field = $query
->addExpression("age*2", 'double_age');
$query
->condition('age', 27);
$result = $query
->execute();
// Check that the aliases are being created the way we want.
$this
->assertEqual($name_field, 'name', 'Name field alias is correct.');
$this
->assertEqual($age_field, 'double_age', 'Age field alias is correct.');
// Ensure that we got the right record.
$record = $result
->fetch();
$this
->assertEqual($record->{$name_field}, 'George', 'Fetched name is correct.');
$this
->assertEqual($record->{$age_field}, 27 * 2, 'Fetched age expression is correct.');
}
/**
* Tests SELECT statements with multiple expressions.
*/
function testSimpleSelectExpressionMultiple() {
$query = db_select('test');
$name_field = $query
->addField('test', 'name');
$age_double_field = $query
->addExpression("age*2");
$age_triple_field = $query
->addExpression("age*3");
$query
->condition('age', 27);
$result = $query
->execute();
// Check that the aliases are being created the way we want.
$this
->assertEqual($age_double_field, 'expression', 'Double age field alias is correct.');
$this
->assertEqual($age_triple_field, 'expression_2', 'Triple age field alias is correct.');
// Ensure that we got the right record.
$record = $result
->fetch();
$this
->assertEqual($record->{$name_field}, 'George', 'Fetched name is correct.');
$this
->assertEqual($record->{$age_double_field}, 27 * 2, 'Fetched double age expression is correct.');
$this
->assertEqual($record->{$age_triple_field}, 27 * 3, 'Fetched triple age expression is correct.');
}
/**
* Tests adding multiple fields to a SELECT statement at the same time.
*/
function testSimpleSelectMultipleFields() {
$record = db_select('test')
->fields('test', array(
'id',
'name',
'age',
'job',
))
->condition('age', 27)
->execute()
->fetchObject();
// Check that all fields we asked for are present.
$this
->assertNotNull($record->id, 'ID field is present.');
$this
->assertNotNull($record->name, 'Name field is present.');
$this
->assertNotNull($record->age, 'Age field is present.');
$this
->assertNotNull($record->job, 'Job field is present.');
// Ensure that we got the right record.
// Check that all fields we asked for are present.
$this
->assertEqual($record->id, 2, 'ID field has the correct value.');
$this
->assertEqual($record->name, 'George', 'Name field has the correct value.');
$this
->assertEqual($record->age, 27, 'Age field has the correct value.');
$this
->assertEqual($record->job, 'Singer', 'Job field has the correct value.');
}
/**
* Tests adding all fields from a given table to a SELECT statement.
*/
function testSimpleSelectAllFields() {
$record = db_select('test')
->fields('test')
->condition('age', 27)
->execute()
->fetchObject();
// Check that all fields we asked for are present.
$this
->assertNotNull($record->id, 'ID field is present.');
$this
->assertNotNull($record->name, 'Name field is present.');
$this
->assertNotNull($record->age, 'Age field is present.');
$this
->assertNotNull($record->job, 'Job field is present.');
// Ensure that we got the right record.
// Check that all fields we asked for are present.
$this
->assertEqual($record->id, 2, 'ID field has the correct value.');
$this
->assertEqual($record->name, 'George', 'Name field has the correct value.');
$this
->assertEqual($record->age, 27, 'Age field has the correct value.');
$this
->assertEqual($record->job, 'Singer', 'Job field has the correct value.');
}
/**
* Tests that a comparison with NULL is always FALSE.
*/
function testNullCondition() {
$this
->ensureSampleDataNull();
$names = db_select('test_null', 'tn')
->fields('tn', array(
'name',
))
->condition('age', NULL)
->execute()
->fetchCol();
$this
->assertEqual(count($names), 0, 'No records found when comparing to NULL.');
}
/**
* Tests that we can find a record with a NULL value.
*/
function testIsNullCondition() {
$this
->ensureSampleDataNull();
$names = db_select('test_null', 'tn')
->fields('tn', array(
'name',
))
->isNull('age')
->execute()
->fetchCol();
$this
->assertEqual(count($names), 1, 'Correct number of records found with NULL age.');
$this
->assertEqual($names[0], 'Fozzie', 'Correct record returned for NULL age.');
}
/**
* Tests that we can find a record without a NULL value.
*/
function testIsNotNullCondition() {
$this
->ensureSampleDataNull();
$names = db_select('test_null', 'tn')
->fields('tn', array(
'name',
))
->isNotNull('tn.age')
->orderBy('name')
->execute()
->fetchCol();
$this
->assertEqual(count($names), 2, 'Correct number of records found withNOT NULL age.');
$this
->assertEqual($names[0], 'Gonzo', 'Correct record returned for NOT NULL age.');
$this
->assertEqual($names[1], 'Kermit', 'Correct record returned for NOT NULL age.');
}
/**
* Tests that we can UNION multiple Select queries together.
*
* This is semantically equal to UNION DISTINCT, so we don't explicity test
* that.
*/
function testUnion() {
$query_1 = db_select('test', 't')
->fields('t', array(
'name',
))
->condition('age', array(
27,
28,
), 'IN');
$query_2 = db_select('test', 't')
->fields('t', array(
'name',
))
->condition('age', 28);
$query_1
->union($query_2);
$names = $query_1
->execute()
->fetchCol();
// Ensure we only get 2 records.
$this
->assertEqual(count($names), 2, 'UNION correctly discarded duplicates.');
$this
->assertEqual($names[0], 'George', 'First query returned correct name.');
$this
->assertEqual($names[1], 'Ringo', 'Second query returned correct name.');
}
/**
* Tests that we can UNION ALL multiple SELECT queries together.
*/
function testUnionAll() {
$query_1 = db_select('test', 't')
->fields('t', array(
'name',
))
->condition('age', array(
27,
28,
), 'IN');
$query_2 = db_select('test', 't')
->fields('t', array(
'name',
))
->condition('age', 28);
$query_1
->union($query_2, 'ALL');
$names = $query_1
->execute()
->fetchCol();
// Ensure we get all 3 records.
$this
->assertEqual(count($names), 3, 'UNION ALL correctly preserved duplicates.');
$this
->assertEqual($names[0], 'George', 'First query returned correct first name.');
$this
->assertEqual($names[1], 'Ringo', 'Second query returned correct second name.');
$this
->assertEqual($names[2], 'Ringo', 'Third query returned correct name.');
}
/**
* Tests that we can get a count query for a UNION Select query.
*/
function testUnionCount() {
$query_1 = db_select('test', 't')
->fields('t', array(
'name',
'age',
))
->condition('age', array(
27,
28,
), 'IN');
$query_2 = db_select('test', 't')
->fields('t', array(
'name',
'age',
))
->condition('age', 28);
$query_1
->union($query_2, 'ALL');
$names = $query_1
->execute()
->fetchCol();
$query_3 = $query_1
->countQuery();
$count = $query_3
->execute()
->fetchField();
// Ensure the counts match.
$this
->assertEqual(count($names), $count, "The count query's result matched the number of rows in the UNION query.");
}
/**
* Tests that random ordering of queries works.
*
* We take the approach of testing the Drupal layer only, rather than trying
* to test that the database's random number generator actually produces
* random queries (which is very difficult to do without an unacceptable risk
* of the test failing by accident).
*
* Therefore, in this test we simply run the same query twice and assert that
* the two results are reordered versions of each other (as well as of the
* same query without the random ordering). It is reasonable to assume that
* if we run the same select query twice and the results are in a different
* order each time, the only way this could happen is if we have successfully
* triggered the database's random ordering functionality.
*/
function testRandomOrder() {
// Use 52 items, so the chance that this test fails by accident will be the
// same as the chance that a deck of cards will come out in the same order
// after shuffling it (in other words, nearly impossible).
$number_of_items = 52;
while (db_query("SELECT MAX(id) FROM {test}")
->fetchField() < $number_of_items) {
db_insert('test')
->fields(array(
'name' => $this
->randomName(),
))
->execute();
}
// First select the items in order and make sure we get an ordered list.
$expected_ids = range(1, $number_of_items);
$ordered_ids = db_select('test', 't')
->fields('t', array(
'id',
))
->range(0, $number_of_items)
->orderBy('id')
->execute()
->fetchCol();
$this
->assertEqual($ordered_ids, $expected_ids, 'A query without random ordering returns IDs in the correct order.');
// Now perform the same query, but instead choose a random ordering. We
// expect this to contain a differently ordered version of the original
// result.
$randomized_ids = db_select('test', 't')
->fields('t', array(
'id',
))
->range(0, $number_of_items)
->orderRandom()
->execute()
->fetchCol();
$this
->assertNotEqual($randomized_ids, $ordered_ids, 'A query with random ordering returns an unordered set of IDs.');
$sorted_ids = $randomized_ids;
sort($sorted_ids);
$this
->assertEqual($sorted_ids, $ordered_ids, 'After sorting the random list, the result matches the original query.');
// Now perform the exact same query again, and make sure the order is
// different.
$randomized_ids_second_set = db_select('test', 't')
->fields('t', array(
'id',
))
->range(0, $number_of_items)
->orderRandom()
->execute()
->fetchCol();
$this
->assertNotEqual($randomized_ids_second_set, $randomized_ids, 'Performing the query with random ordering a second time returns IDs in a different order.');
$sorted_ids_second_set = $randomized_ids_second_set;
sort($sorted_ids_second_set);
$this
->assertEqual($sorted_ids_second_set, $sorted_ids, 'After sorting the second random list, the result matches the sorted version of the first random list.');
}
/**
* Tests that aliases are renamed when they are duplicates.
*/
function testSelectDuplicateAlias() {
$query = db_select('test', 't');
$alias1 = $query
->addField('t', 'name', 'the_alias');
$alias2 = $query
->addField('t', 'age', 'the_alias');
$this
->assertNotIdentical($alias1, $alias2, 'Duplicate aliases are renamed.');
}
/**
* Tests that an invalid merge query throws an exception.
*/
function testInvalidSelectCount() {
try {
// This query will fail because the table does not exist.
// Normally it would throw an exception but we are supressing
// it with the throw_exception option.
$options['throw_exception'] = FALSE;
db_select('some_table_that_doesnt_exist', 't', $options)
->fields('t')
->countQuery()
->execute();
$this
->pass('$options[\'throw_exception\'] is FALSE, no Exception thrown.');
} catch (\Exception $e) {
$this
->fail('$options[\'throw_exception\'] is FALSE, but Exception thrown for invalid query.');
return;
}
try {
// This query will fail because the table does not exist.
db_select('some_table_that_doesnt_exist', 't')
->fields('t')
->countQuery()
->execute();
} catch (\Exception $e) {
$this
->pass('Exception thrown for invalid query.');
return;
}
$this
->fail('No Exception thrown.');
}
}
Name | Modifiers | Type | Description | Overrides |
---|---|---|---|---|
DatabaseTestBase:: |
public static | property |
Modules to enable. Overrides DrupalUnitTestBase:: |
3 |
DatabaseTestBase:: |
static | function | Sets up our sample data. | |
DatabaseTestBase:: |
function | Sets up tables for NULL handling. | ||
DatabaseTestBase:: |
function |
Sets up Drupal unit test environment. Overrides DrupalUnitTestBase:: |
||
DrupalUnitTestBase:: |
protected | property | A KeyValueMemoryFactory instance to use when building the container. | |
DrupalUnitTestBase:: |
private | property | ||
DrupalUnitTestBase:: |
private | property | ||
DrupalUnitTestBase:: |
private | property | ||
DrupalUnitTestBase:: |
public | function | Sets up the base service container for this test. | 1 |
DrupalUnitTestBase:: |
protected | function | Disables modules for this test. | |
DrupalUnitTestBase:: |
protected | function | Enables modules for this test. | |
DrupalUnitTestBase:: |
protected | function | Installs default configuration for a given list of modules. | |
DrupalUnitTestBase:: |
protected | function | Installs a specific table from a module schema definition. | |
DrupalUnitTestBase:: |
protected | function |
Deletes created files, database tables, and reverts all environment changes. Overrides TestBase:: |
2 |
DrupalUnitTestBase:: |
function |
Overrides \Drupal\simpletest\UnitTestBase::__construct(). Overrides UnitTestBase:: |
||
SelectTest:: |
public static | function | ||
SelectTest:: |
function | Tests that an invalid merge query throws an exception. | ||
SelectTest:: |
function | Tests that we can find a record without a NULL value. | ||
SelectTest:: |
function | Tests that we can find a record with a NULL value. | ||
SelectTest:: |
function | Tests that a comparison with NULL is always FALSE. | ||
SelectTest:: |
function | Tests that random ordering of queries works. | ||
SelectTest:: |
function | Tests that aliases are renamed when they are duplicates. | ||
SelectTest:: |
function | Tests rudimentary SELECT statement with a COMMENT. | ||
SelectTest:: |
function | Tests rudimentary SELECT statements. | ||
SelectTest:: |
function | Tests adding all fields from a given table to a SELECT statement. | ||
SelectTest:: |
function | Tests basic conditionals on SELECT statements. | ||
SelectTest:: |
function | Tests SELECT statements with expressions. | ||
SelectTest:: |
function | Tests SELECT statements with multiple expressions. | ||
SelectTest:: |
function | Tests adding multiple fields to a SELECT statement at the same time. | ||
SelectTest:: |
function | Tests that we can UNION multiple Select queries together. | ||
SelectTest:: |
function | Tests that we can UNION ALL multiple SELECT queries together. | ||
SelectTest:: |
function | Tests that we can get a count query for a UNION Select query. | ||
SelectTest:: |
function | Tests query COMMENT system against vulnerabilities. | ||
TestBase:: |
protected | property | Assertions thrown in that test case. | |
TestBase:: |
protected | property | The config importer that can used in a test. | 1 |
TestBase:: |
protected | property | The dependency injection container used in the test. | 1 |
TestBase:: |
protected | property | The database prefix of this test run. | |
TestBase:: |
public | property | Whether to die in case any test assertion fails. | |
TestBase:: |
protected | property | The original file directory, before it was changed for testing purposes. | |
TestBase:: |
protected | property | The original database prefix when running inside Simpletest. | |
TestBase:: |
protected | property | The settings array. | |
TestBase:: |
protected | property | The public file directory for the test environment. | |
TestBase:: |
public | property | Current results of this test case. | |
TestBase:: |
protected | property | Flag to indicate whether the test has been set up. | |
TestBase:: |
protected | property | ||
TestBase:: |
protected | property | ||
TestBase:: |
protected | property | This class is skipped when looking for the source of an assertion. | |
TestBase:: |
protected | property | The test run ID. | |
TestBase:: |
protected | property | Time limit for the test. | |
TestBase:: |
protected | property | TRUE if verbose debugging is enabled. | |
TestBase:: |
protected | property | Safe class name for use in verbose output filenames. | |
TestBase:: |
protected | property | Directory where verbose output files are put. | |
TestBase:: |
protected | property | URL to the verbose output file directory. | |
TestBase:: |
protected | property | Incrementing identifier for verbose output filenames. | |
TestBase:: |
protected | function | Internal helper: stores the assert. | |
TestBase:: |
protected | function | Check to see if two values are equal. | |
TestBase:: |
protected | function | Check to see if a value is false (an empty string, 0, NULL, or FALSE). | |
TestBase:: |
protected | function | Check to see if two values are identical. | |
TestBase:: |
protected | function | Checks to see if two objects are identical. | |
TestBase:: |
protected | function | Check to see if two values are not equal. | |
TestBase:: |
protected | function | Check to see if two values are not identical. | |
TestBase:: |
protected | function | Check to see if a value is not NULL. | |
TestBase:: |
protected | function | Check to see if a value is NULL. | |
TestBase:: |
protected | function | Check to see if a value is not false (not an empty string, 0, NULL, or FALSE). | |
TestBase:: |
protected | function | Changes the database connection to the prefixed one. | |
TestBase:: |
protected | function | Checks the matching requirements for Test. | 4 |
TestBase:: |
public | function | Returns a ConfigImporter object to import test importing of configuration. | 1 |
TestBase:: |
public | function | Copies configuration objects from source storage to target storage. | |
TestBase:: |
public static | function | Delete an assertion record by message ID. | |
TestBase:: |
protected | function | Fire an error assertion. | 1 |
TestBase:: |
public | function | Handle errors during test runs. | |
TestBase:: |
protected | function | Handle exceptions. | |
TestBase:: |
protected | function | Fire an assertion that is always negative. | |
TestBase:: |
public static | function | Ensures test files are deletable within file_unmanaged_delete_recursive(). | |
TestBase:: |
public static | function | Converts a list of possible parameters into a stack of permutations. | |
TestBase:: |
protected | function | Cycles through backtrace until the first non-assertion method is found. | |
TestBase:: |
public static | function | Returns the database connection to the site running Simpletest. | |
TestBase:: |
public static | function | Store an assertion from outside the testing context. | |
TestBase:: |
protected | function | Fire an assertion that is always positive. | |
TestBase:: |
protected | function | Create and set new configuration directories. | 1 |
TestBase:: |
protected | function | Generates a database prefix for running tests. | |
TestBase:: |
protected | function | Prepares the current environment for running the test. | |
TestBase:: |
public static | function | Generates a random string containing letters and numbers. | |
TestBase:: |
public static | function | Generates a random PHP object. | |
TestBase:: |
public static | function | Generates a random string of ASCII characters of codes 32 to 126. | |
TestBase:: |
protected | function | Rebuild drupal_container(). | 1 |
TestBase:: |
public | function | Run all tests in this class. | |
TestBase:: |
protected | function | Changes in memory settings. | |
TestBase:: |
protected | function | Logs verbose message in a text file. | |
UnitTestBase:: |
protected | property |