Update to MediaWiki 1.21.2

6 files changed, 1319 insertions, 0 deletions

diff --git a/tests/phpunit/includes/db/DatabaseSQLTest.php b/tests/phpunit/includes/db/DatabaseSQLTest.php
new file mode 100644
index 00000000..09792438
--- /dev/null
+++ b/tests/phpunit/includes/db/DatabaseSQLTest.php
@@ -0,0 +1,148 @@
+<?php
+
+/**
+ * Test the abstract database layer
+ * Using Mysql for the sql at the moment TODO
+ *
+ * @group Database
+ */
+class DatabaseSQLTest extends MediaWikiTestCase {
+
+	protected function setUp() {
+		parent::setUp();
+		// TODO support other DBMS or find another way to do it
+		if ( $this->db->getType() !== 'mysql' ) {
+			$this->markTestSkipped( 'No mysql database' );
+		}
+	}
+
+	/**
+	 * @dataProvider provideSelectSQLText
+	 */
+	function testSelectSQLText( $sql, $sqlText ) {
+		$this->assertEquals( trim( $this->db->selectSQLText(
+			isset( $sql['tables'] ) ? $sql['tables'] : array(),
+			isset( $sql['fields'] ) ? $sql['fields'] : array(),
+			isset( $sql['conds'] ) ? $sql['conds'] : array(),
+			__METHOD__,
+			isset( $sql['options'] ) ? $sql['options'] : array(),
+			isset( $sql['join_conds'] ) ? $sql['join_conds'] : array()
+		) ), $sqlText );
+	}
+
+	public static function provideSelectSQLText() {
+		return array(
+			array(
+				array(
+					'tables' => 'table',
+					'fields' => array( 'field', 'alias' => 'field2' ),
+					'conds' => array( 'alias' => 'text' ),
+				),
+				"SELECT  field,field2 AS alias  " .
+					"FROM `unittest_table`  " .
+					"WHERE alias = 'text'"
+			),
+			array(
+				array(
+					'tables' => 'table',
+					'fields' => array( 'field', 'alias' => 'field2' ),
+					'conds' => array( 'alias' => 'text' ),
+					'options' => array( 'LIMIT' => 1, 'ORDER BY' => 'field' ),
+				),
+				"SELECT  field,field2 AS alias  " .
+					"FROM `unittest_table`  " .
+					"WHERE alias = 'text'  " .
+					"ORDER BY field " .
+					"LIMIT 1"
+			),
+			array(
+				array(
+					'tables' => array( 'table', 't2' => 'table2' ),
+					'fields' => array( 'tid', 'field', 'alias' => 'field2', 't2.id' ),
+					'conds' => array( 'alias' => 'text' ),
+					'options' => array( 'LIMIT' => 1, 'ORDER BY' => 'field' ),
+					'join_conds' => array( 't2' => array(
+						'LEFT JOIN', 'tid = t2.id'
+					) ),
+				),
+				"SELECT  tid,field,field2 AS alias,t2.id  " .
+					"FROM `unittest_table` LEFT JOIN `unittest_table2` `t2` ON ((tid = t2.id))  " .
+					"WHERE alias = 'text'  " .
+					"ORDER BY field " .
+					"LIMIT 1"
+			),
+			array(
+				array(
+					'tables' => array( 'table', 't2' => 'table2' ),
+					'fields' => array( 'tid', 'field', 'alias' => 'field2', 't2.id' ),
+					'conds' => array( 'alias' => 'text' ),
+					'options' => array( 'LIMIT' => 1, 'GROUP BY' => 'field', 'HAVING' => 'COUNT(*) > 1' ),
+					'join_conds' => array( 't2' => array(
+						'LEFT JOIN', 'tid = t2.id'
+					) ),
+				),
+				"SELECT  tid,field,field2 AS alias,t2.id  " .
+					"FROM `unittest_table` LEFT JOIN `unittest_table2` `t2` ON ((tid = t2.id))  " .
+					"WHERE alias = 'text'  " .
+					"GROUP BY field HAVING COUNT(*) > 1 " .
+					"LIMIT 1"
+			),
+			array(
+				array(
+					'tables' => array( 'table', 't2' => 'table2' ),
+					'fields' => array( 'tid', 'field', 'alias' => 'field2', 't2.id' ),
+					'conds' => array( 'alias' => 'text' ),
+					'options' => array( 'LIMIT' => 1, 'GROUP BY' => array( 'field', 'field2' ), 'HAVING' => array( 'COUNT(*) > 1', 'field' => 1 ) ),
+					'join_conds' => array( 't2' => array(
+						'LEFT JOIN', 'tid = t2.id'
+					) ),
+				),
+				"SELECT  tid,field,field2 AS alias,t2.id  " .
+					"FROM `unittest_table` LEFT JOIN `unittest_table2` `t2` ON ((tid = t2.id))  " .
+					"WHERE alias = 'text'  " .
+					"GROUP BY field,field2 HAVING (COUNT(*) > 1) AND field = '1' " .
+					"LIMIT 1"
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider provideConditional
+	 */
+	function testConditional( $sql, $sqlText ) {
+		$this->assertEquals( trim( $this->db->conditional(
+			$sql['conds'],
+			$sql['true'],
+			$sql['false']
+		) ), $sqlText );
+	}
+
+	public static function provideConditional() {
+		return array(
+			array(
+				array(
+					'conds' => array( 'field' => 'text' ),
+					'true' => 1,
+					'false' => 'NULL',
+				),
+				"(CASE WHEN field = 'text' THEN 1 ELSE NULL END)"
+			),
+			array(
+				array(
+					'conds' => array( 'field' => 'text', 'field2' => 'anothertext' ),
+					'true' => 1,
+					'false' => 'NULL',
+				),
+				"(CASE WHEN field = 'text' AND field2 = 'anothertext' THEN 1 ELSE NULL END)"
+			),
+			array(
+				array(
+					'conds' => 'field=1',
+					'true' => 1,
+					'false' => 'NULL',
+				),
+				"(CASE WHEN field=1 THEN 1 ELSE NULL END)"
+			),
+		);
+	}
+}
diff --git a/tests/phpunit/includes/db/DatabaseSqliteTest.php b/tests/phpunit/includes/db/DatabaseSqliteTest.php
new file mode 100644
index 00000000..7b84d471
--- /dev/null
+++ b/tests/phpunit/includes/db/DatabaseSqliteTest.php
@@ -0,0 +1,389 @@
+<?php
+
+class MockDatabaseSqlite extends DatabaseSqliteStandalone {
+	var $lastQuery;
+
+	function __construct() {
+		parent::__construct( ':memory:' );
+	}
+
+	function query( $sql, $fname = '', $tempIgnore = false ) {
+		$this->lastQuery = $sql;
+		return true;
+	}
+
+	/**
+	 * Override parent visibility to public
+	 */
+	public function replaceVars( $s ) {
+		return parent::replaceVars( $s );
+	}
+}
+
+/**
+ * @group sqlite
+ * @group Database
+ * @group medium
+ */
+class DatabaseSqliteTest extends MediaWikiTestCase {
+	var $db;
+
+	protected function setUp() {
+		parent::setUp();
+
+		if ( !Sqlite::isPresent() ) {
+			$this->markTestSkipped( 'No SQLite support detected' );
+		}
+		$this->db = new MockDatabaseSqlite();
+		if ( version_compare( $this->db->getServerVersion(), '3.6.0', '<' ) ) {
+			$this->markTestSkipped( "SQLite at least 3.6 required, {$this->db->getServerVersion()} found" );
+		}
+	}
+
+	private function replaceVars( $sql ) {
+		// normalize spacing to hide implementation details
+		return preg_replace( '/\s+/', ' ', $this->db->replaceVars( $sql ) );
+	}
+
+	private function assertResultIs( $expected, $res ) {
+		$this->assertNotNull( $res );
+		$i = 0;
+		foreach ( $res as $row ) {
+			foreach ( $expected[$i] as $key => $value ) {
+				$this->assertTrue( isset( $row->$key ) );
+				$this->assertEquals( $value, $row->$key );
+			}
+			$i++;
+		}
+		$this->assertEquals( count( $expected ), $i, 'Unexpected number of rows' );
+	}
+
+	public static function provideAddQuotes() {
+		return array(
+			array( // #0: empty
+				'', "''"
+			),
+			array( // #1: simple
+				'foo bar', "'foo bar'"
+			),
+			array( // #2: including quote
+				'foo\'bar', "'foo''bar'"
+			),
+			array( // #3: including \0 (must be represented as hex, per https://bugs.php.net/bug.php?id=63419)
+				"x\0y",
+				"x'780079'",
+			),
+			array( // #4: blob object (must be represented as hex)
+				new Blob( "hello" ),
+				"x'68656c6c6f'",
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider provideAddQuotes()
+	 */
+	public function testAddQuotes( $value, $expected ) {
+		// check quoting
+		$db = new DatabaseSqliteStandalone( ':memory:' );
+		$this->assertEquals( $expected, $db->addQuotes( $value ), 'string not quoted as expected' );
+
+		// ok, quoting works as expected, now try a round trip.
+		$re = $db->query( 'select ' . $db->addQuotes( $value ) );
+
+		$this->assertTrue( $re !== false, 'query failed' );
+
+		if ( $row = $re->fetchRow() ) {
+			if ( $value instanceof Blob ) {
+				$value = $value->fetch();
+			}
+
+			$this->assertEquals( $value, $row[0], 'string mangled by the database' );
+		} else {
+			$this->fail( 'query returned no result' );
+		}
+	}
+
+	public function testReplaceVars() {
+		$this->assertEquals( 'foo', $this->replaceVars( 'foo' ), "Don't break anything accidentally" );
+
+		$this->assertEquals( "CREATE TABLE /**/foo (foo_key INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, "
+				. "foo_bar TEXT, foo_name TEXT NOT NULL DEFAULT '', foo_int INTEGER, foo_int2 INTEGER );",
+			$this->replaceVars( "CREATE TABLE /**/foo (foo_key int unsigned NOT NULL PRIMARY KEY AUTO_INCREMENT,
+			foo_bar char(13), foo_name varchar(255) binary NOT NULL DEFAULT '', foo_int tinyint ( 8 ), foo_int2 int(16) ) ENGINE=MyISAM;" )
+		);
+
+		$this->assertEquals( "CREATE TABLE foo ( foo1 REAL, foo2 REAL, foo3 REAL );",
+			$this->replaceVars( "CREATE TABLE foo ( foo1 FLOAT, foo2 DOUBLE( 1,10), foo3 DOUBLE PRECISION );" )
+		);
+
+		$this->assertEquals( "CREATE TABLE foo ( foo_binary1 BLOB, foo_binary2 BLOB );",
+			$this->replaceVars( "CREATE TABLE foo ( foo_binary1 binary(16), foo_binary2 varbinary(32) );" )
+		);
+
+		$this->assertEquals( "CREATE TABLE text ( text_foo TEXT );",
+			$this->replaceVars( "CREATE TABLE text ( text_foo tinytext );" ),
+			'Table name changed'
+		);
+
+		$this->assertEquals( "CREATE TABLE foo ( foobar INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL );",
+			$this->replaceVars( "CREATE TABLE foo ( foobar INT PRIMARY KEY NOT NULL AUTO_INCREMENT );" )
+		);
+		$this->assertEquals( "CREATE TABLE foo ( foobar INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL );",
+			$this->replaceVars( "CREATE TABLE foo ( foobar INT PRIMARY KEY AUTO_INCREMENT NOT NULL );" )
+		);
+
+		$this->assertEquals( "CREATE TABLE enums( enum1 TEXT, myenum TEXT)",
+			$this->replaceVars( "CREATE TABLE enums( enum1 ENUM('A', 'B'), myenum ENUM ('X', 'Y'))" )
+		);
+
+		$this->assertEquals( "ALTER TABLE foo ADD COLUMN foo_bar INTEGER DEFAULT 42",
+			$this->replaceVars( "ALTER TABLE foo\nADD COLUMN foo_bar int(10) unsigned DEFAULT 42" )
+		);
+	}
+
+	public function testTableName() {
+		// @todo Moar!
+		$db = new DatabaseSqliteStandalone( ':memory:' );
+		$this->assertEquals( 'foo', $db->tableName( 'foo' ) );
+		$this->assertEquals( 'sqlite_master', $db->tableName( 'sqlite_master' ) );
+		$db->tablePrefix( 'foo' );
+		$this->assertEquals( 'sqlite_master', $db->tableName( 'sqlite_master' ) );
+		$this->assertEquals( 'foobar', $db->tableName( 'bar' ) );
+	}
+
+	public function testDuplicateTableStructure() {
+		$db = new DatabaseSqliteStandalone( ':memory:' );
+		$db->query( 'CREATE TABLE foo(foo, barfoo)' );
+
+		$db->duplicateTableStructure( 'foo', 'bar' );
+		$this->assertEquals( 'CREATE TABLE "bar"(foo, barfoo)',
+			$db->selectField( 'sqlite_master', 'sql', array( 'name' => 'bar' ) ),
+			'Normal table duplication'
+		);
+
+		$db->duplicateTableStructure( 'foo', 'baz', true );
+		$this->assertEquals( 'CREATE TABLE "baz"(foo, barfoo)',
+			$db->selectField( 'sqlite_temp_master', 'sql', array( 'name' => 'baz' ) ),
+			'Creation of temporary duplicate'
+		);
+		$this->assertEquals( 0,
+			$db->selectField( 'sqlite_master', 'COUNT(*)', array( 'name' => 'baz' ) ),
+			'Create a temporary duplicate only'
+		);
+	}
+
+	public function testDuplicateTableStructureVirtual() {
+		$db = new DatabaseSqliteStandalone( ':memory:' );
+		if ( $db->getFulltextSearchModule() != 'FTS3' ) {
+			$this->markTestSkipped( 'FTS3 not supported, cannot create virtual tables' );
+		}
+		$db->query( 'CREATE VIRTUAL TABLE "foo" USING FTS3(foobar)' );
+
+		$db->duplicateTableStructure( 'foo', 'bar' );
+		$this->assertEquals( 'CREATE VIRTUAL TABLE "bar" USING FTS3(foobar)',
+			$db->selectField( 'sqlite_master', 'sql', array( 'name' => 'bar' ) ),
+			'Duplication of virtual tables'
+		);
+
+		$db->duplicateTableStructure( 'foo', 'baz', true );
+		$this->assertEquals( 'CREATE VIRTUAL TABLE "baz" USING FTS3(foobar)',
+			$db->selectField( 'sqlite_master', 'sql', array( 'name' => 'baz' ) ),
+			"Can't create temporary virtual tables, should fall back to non-temporary duplication"
+		);
+	}
+
+	public function testDeleteJoin() {
+		$db = new DatabaseSqliteStandalone( ':memory:' );
+		$db->query( 'CREATE TABLE a (a_1)', __METHOD__ );
+		$db->query( 'CREATE TABLE b (b_1, b_2)', __METHOD__ );
+		$db->insert( 'a', array(
+				array( 'a_1' => 1 ),
+				array( 'a_1' => 2 ),
+				array( 'a_1' => 3 ),
+			),
+			__METHOD__
+		);
+		$db->insert( 'b', array(
+				array( 'b_1' => 2, 'b_2' => 'a' ),
+				array( 'b_1' => 3, 'b_2' => 'b' ),
+			),
+			__METHOD__
+		);
+		$db->deleteJoin( 'a', 'b', 'a_1', 'b_1', array( 'b_2' => 'a' ), __METHOD__ );
+		$res = $db->query( "SELECT * FROM a", __METHOD__ );
+		$this->assertResultIs( array(
+				array( 'a_1' => 1 ),
+				array( 'a_1' => 3 ),
+			),
+			$res
+		);
+	}
+
+	public function testEntireSchema() {
+		global $IP;
+
+		$result = Sqlite::checkSqlSyntax( "$IP/maintenance/tables.sql" );
+		if ( $result !== true ) {
+			$this->fail( $result );
+		}
+		$this->assertTrue( true ); // avoid test being marked as incomplete due to lack of assertions
+	}
+
+	/**
+	 * Runs upgrades of older databases and compares results with current schema
+	 * @todo: currently only checks list of tables
+	 */
+	public function testUpgrades() {
+		global $IP, $wgVersion, $wgProfileToDatabase;
+
+		// Versions tested
+		$versions = array(
+			//'1.13', disabled for now, was totally screwed up
+			// SQLite wasn't included in 1.14
+			'1.15',
+			'1.16',
+			'1.17',
+			'1.18',
+		);
+
+		// Mismatches for these columns we can safely ignore
+		$ignoredColumns = array(
+			'user_newtalk.user_last_timestamp', // r84185
+		);
+
+		$currentDB = new DatabaseSqliteStandalone( ':memory:' );
+		$currentDB->sourceFile( "$IP/maintenance/tables.sql" );
+		if ( $wgProfileToDatabase ) {
+			$currentDB->sourceFile( "$IP/maintenance/sqlite/archives/patch-profiling.sql" );
+		}
+		$currentTables = $this->getTables( $currentDB );
+		sort( $currentTables );
+
+		foreach ( $versions as $version ) {
+			$versions = "upgrading from $version to $wgVersion";
+			$db = $this->prepareDB( $version );
+			$tables = $this->getTables( $db );
+			$this->assertEquals( $currentTables, $tables, "Different tables $versions" );
+			foreach ( $tables as $table ) {
+				$currentCols = $this->getColumns( $currentDB, $table );
+				$cols = $this->getColumns( $db, $table );
+				$this->assertEquals(
+					array_keys( $currentCols ),
+					array_keys( $cols ),
+					"Mismatching columns for table \"$table\" $versions"
+				);
+				foreach ( $currentCols as $name => $column ) {
+					$fullName = "$table.$name";
+					$this->assertEquals(
+						(bool)$column->pk,
+						(bool)$cols[$name]->pk,
+						"PRIMARY KEY status does not match for column $fullName $versions"
+					);
+					if ( !in_array( $fullName, $ignoredColumns ) ) {
+						$this->assertEquals(
+							(bool)$column->notnull,
+							(bool)$cols[$name]->notnull,
+							"NOT NULL status does not match for column $fullName $versions"
+						);
+						$this->assertEquals(
+							$column->dflt_value,
+							$cols[$name]->dflt_value,
+							"Default values does not match for column $fullName $versions"
+						);
+					}
+				}
+				$currentIndexes = $this->getIndexes( $currentDB, $table );
+				$indexes = $this->getIndexes( $db, $table );
+				$this->assertEquals(
+					array_keys( $currentIndexes ),
+					array_keys( $indexes ),
+					"mismatching indexes for table \"$table\" $versions"
+				);
+			}
+			$db->close();
+		}
+	}
+
+	public function testInsertIdType() {
+		$db = new DatabaseSqliteStandalone( ':memory:' );
+		$this->assertInstanceOf( 'ResultWrapper',
+			$db->query( 'CREATE TABLE a ( a_1 )', __METHOD__ ), "Database creationg" );
+		$this->assertTrue( $db->insert( 'a', array( 'a_1' => 10 ), __METHOD__ ),
+			"Insertion worked" );
+		$this->assertEquals( "integer", gettype( $db->insertId() ), "Actual typecheck" );
+		$this->assertTrue( $db->close(), "closing database" );
+	}
+
+	private function prepareDB( $version ) {
+		static $maint = null;
+		if ( $maint === null ) {
+			$maint = new FakeMaintenance();
+			$maint->loadParamsAndArgs( null, array( 'quiet' => 1 ) );
+		}
+
+		global $IP;
+		$db = new DatabaseSqliteStandalone( ':memory:' );
+		$db->sourceFile( "$IP/tests/phpunit/data/db/sqlite/tables-$version.sql" );
+		$updater = DatabaseUpdater::newForDB( $db, false, $maint );
+		$updater->doUpdates( array( 'core' ) );
+		return $db;
+	}
+
+	private function getTables( $db ) {
+		$list = array_flip( $db->listTables() );
+		$excluded = array(
+			'math', // moved out of core in 1.18
+			'trackbacks', // removed from core in 1.19
+			'searchindex',
+			'searchindex_content',
+			'searchindex_segments',
+			'searchindex_segdir',
+			// FTS4 ready!!1
+			'searchindex_docsize',
+			'searchindex_stat',
+		);
+		foreach ( $excluded as $t ) {
+			unset( $list[$t] );
+		}
+		$list = array_flip( $list );
+		sort( $list );
+		return $list;
+	}
+
+	private function getColumns( $db, $table ) {
+		$cols = array();
+		$res = $db->query( "PRAGMA table_info($table)" );
+		$this->assertNotNull( $res );
+		foreach ( $res as $col ) {
+			$cols[$col->name] = $col;
+		}
+		ksort( $cols );
+		return $cols;
+	}
+
+	private function getIndexes( $db, $table ) {
+		$indexes = array();
+		$res = $db->query( "PRAGMA index_list($table)" );
+		$this->assertNotNull( $res );
+		foreach ( $res as $index ) {
+			$res2 = $db->query( "PRAGMA index_info({$index->name})" );
+			$this->assertNotNull( $res2 );
+			$index->columns = array();
+			foreach ( $res2 as $col ) {
+				$index->columns[] = $col;
+			}
+			$indexes[$index->name] = $index;
+		}
+		ksort( $indexes );
+		return $indexes;
+	}
+
+	function testCaseInsensitiveLike() {
+		// TODO: Test this for all databases
+		$db = new DatabaseSqliteStandalone( ':memory:' );
+		$res = $db->query( 'SELECT "a" LIKE "A" AS a' );
+		$row = $res->fetchRow();
+		$this->assertFalse( (bool)$row['a'] );
+	}
+}
diff --git a/tests/phpunit/includes/db/DatabaseTest.php b/tests/phpunit/includes/db/DatabaseTest.php
new file mode 100644
index 00000000..65c80d1d
--- /dev/null
+++ b/tests/phpunit/includes/db/DatabaseTest.php
@@ -0,0 +1,212 @@
+<?php
+
+/**
+ * @group Database
+ * @group DatabaseBase
+ */
+class DatabaseTest extends MediaWikiTestCase {
+	var $db, $functionTest = false;
+
+	protected function setUp() {
+		parent::setUp();
+		$this->db = wfGetDB( DB_MASTER );
+	}
+
+	protected function tearDown() {
+		parent::tearDown();
+		if ( $this->functionTest ) {
+			$this->dropFunctions();
+			$this->functionTest = false;
+		}
+	}
+
+	function testAddQuotesNull() {
+		$check = "NULL";
+		if ( $this->db->getType() === 'sqlite' || $this->db->getType() === 'oracle' ) {
+			$check = "''";
+		}
+		$this->assertEquals( $check, $this->db->addQuotes( null ) );
+	}
+
+	function testAddQuotesInt() {
+		# returning just "1234" should be ok too, though...
+		# maybe
+		$this->assertEquals(
+			"'1234'",
+			$this->db->addQuotes( 1234 ) );
+	}
+
+	function testAddQuotesFloat() {
+		# returning just "1234.5678" would be ok too, though
+		$this->assertEquals(
+			"'1234.5678'",
+			$this->db->addQuotes( 1234.5678 ) );
+	}
+
+	function testAddQuotesString() {
+		$this->assertEquals(
+			"'string'",
+			$this->db->addQuotes( 'string' ) );
+	}
+
+	function testAddQuotesStringQuote() {
+		$check = "'string''s cause trouble'";
+		if ( $this->db->getType() === 'mysql' ) {
+			$check = "'string\'s cause trouble'";
+		}
+		$this->assertEquals(
+			$check,
+			$this->db->addQuotes( "string's cause trouble" ) );
+	}
+
+	private function getSharedTableName( $table, $database, $prefix, $format = 'quoted' ) {
+		global $wgSharedDB, $wgSharedTables, $wgSharedPrefix;
+
+		$oldName = $wgSharedDB;
+		$oldTables = $wgSharedTables;
+		$oldPrefix = $wgSharedPrefix;
+
+		$wgSharedDB = $database;
+		$wgSharedTables = array( $table );
+		$wgSharedPrefix = $prefix;
+
+		$ret = $this->db->tableName( $table, $format );
+
+		$wgSharedDB = $oldName;
+		$wgSharedTables = $oldTables;
+		$wgSharedPrefix = $oldPrefix;
+
+		return $ret;
+	}
+
+	private function prefixAndQuote( $table, $database = null, $prefix = null, $format = 'quoted' ) {
+		if ( $this->db->getType() === 'sqlite' || $format !== 'quoted' ) {
+			$quote = '';
+		} elseif ( $this->db->getType() === 'mysql' ) {
+			$quote = '`';
+		} else {
+			$quote = '"';
+		}
+
+		if ( $database !== null ) {
+			$database = $quote . $database . $quote . '.';
+		}
+
+		if ( $prefix === null ) {
+			$prefix = $this->dbPrefix();
+		}
+
+		return $database . $quote . $prefix . $table . $quote;
+	}
+
+	function testTableNameLocal() {
+		$this->assertEquals(
+			$this->prefixAndQuote( 'tablename' ),
+			$this->db->tableName( 'tablename' )
+		);
+	}
+
+	function testTableNameRawLocal() {
+		$this->assertEquals(
+			$this->prefixAndQuote( 'tablename', null, null, 'raw' ),
+			$this->db->tableName( 'tablename', 'raw' )
+		);
+	}
+
+	function testTableNameShared() {
+		$this->assertEquals(
+			$this->prefixAndQuote( 'tablename', 'sharedatabase', 'sh_' ),
+			$this->getSharedTableName( 'tablename', 'sharedatabase', 'sh_' )
+		);
+
+		$this->assertEquals(
+			$this->prefixAndQuote( 'tablename', 'sharedatabase', null ),
+			$this->getSharedTableName( 'tablename', 'sharedatabase', null )
+		);
+	}
+
+	function testTableNameRawShared() {
+		$this->assertEquals(
+			$this->prefixAndQuote( 'tablename', 'sharedatabase', 'sh_', 'raw' ),
+			$this->getSharedTableName( 'tablename', 'sharedatabase', 'sh_', 'raw' )
+		);
+
+		$this->assertEquals(
+			$this->prefixAndQuote( 'tablename', 'sharedatabase', null, 'raw' ),
+			$this->getSharedTableName( 'tablename', 'sharedatabase', null, 'raw' )
+		);
+	}
+
+	function testTableNameForeign() {
+		$this->assertEquals(
+			$this->prefixAndQuote( 'tablename', 'databasename', '' ),
+			$this->db->tableName( 'databasename.tablename' )
+		);
+	}
+
+	function testTableNameRawForeign() {
+		$this->assertEquals(
+			$this->prefixAndQuote( 'tablename', 'databasename', '', 'raw' ),
+			$this->db->tableName( 'databasename.tablename', 'raw' )
+		);
+	}
+
+	function testFillPreparedEmpty() {
+		$sql = $this->db->fillPrepared(
+			'SELECT * FROM interwiki', array() );
+		$this->assertEquals(
+			"SELECT * FROM interwiki",
+			$sql );
+	}
+
+	function testFillPreparedQuestion() {
+		$sql = $this->db->fillPrepared(
+			'SELECT * FROM cur WHERE cur_namespace=? AND cur_title=?',
+			array( 4, "Snicker's_paradox" ) );
+
+		$check = "SELECT * FROM cur WHERE cur_namespace='4' AND cur_title='Snicker''s_paradox'";
+		if ( $this->db->getType() === 'mysql' ) {
+			$check = "SELECT * FROM cur WHERE cur_namespace='4' AND cur_title='Snicker\'s_paradox'";
+		}
+		$this->assertEquals( $check, $sql );
+	}
+
+	function testFillPreparedBang() {
+		$sql = $this->db->fillPrepared(
+			'SELECT user_id FROM ! WHERE user_name=?',
+			array( '"user"', "Slash's Dot" ) );
+
+		$check = "SELECT user_id FROM \"user\" WHERE user_name='Slash''s Dot'";
+		if ( $this->db->getType() === 'mysql' ) {
+			$check = "SELECT user_id FROM \"user\" WHERE user_name='Slash\'s Dot'";
+		}
+		$this->assertEquals( $check, $sql );
+	}
+
+	function testFillPreparedRaw() {
+		$sql = $this->db->fillPrepared(
+			"SELECT * FROM cur WHERE cur_title='This_\\&_that,_WTF\\?\\!'",
+			array( '"user"', "Slash's Dot" ) );
+		$this->assertEquals(
+			"SELECT * FROM cur WHERE cur_title='This_&_that,_WTF?!'",
+			$sql );
+	}
+
+	function testStoredFunctions() {
+		if ( !in_array( wfGetDB( DB_MASTER )->getType(), array( 'mysql', 'postgres' ) ) ) {
+			$this->markTestSkipped( 'MySQL or Postgres required' );
+		}
+		global $IP;
+		$this->dropFunctions();
+		$this->functionTest = true;
+		$this->assertTrue( $this->db->sourceFile( "$IP/tests/phpunit/data/db/{$this->db->getType()}/functions.sql" ) );
+		$res = $this->db->query( 'SELECT mw_test_function() AS test', __METHOD__ );
+		$this->assertEquals( 42, $res->fetchObject()->test );
+	}
+
+	private function dropFunctions() {
+		$this->db->query( 'DROP FUNCTION IF EXISTS mw_test_function'
+				. ( $this->db->getType() == 'postgres' ? '()' : '' )
+		);
+	}
+}
diff --git a/tests/phpunit/includes/db/ORMRowTest.php b/tests/phpunit/includes/db/ORMRowTest.php
new file mode 100644
index 00000000..596d0bd0
--- /dev/null
+++ b/tests/phpunit/includes/db/ORMRowTest.php
@@ -0,0 +1,225 @@
+<?php
+
+/**
+ * Abstract class to construct tests for ORMRow deriving classes.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * http://www.gnu.org/copyleft/gpl.html
+ *
+ * @file
+ * @since 1.20
+ *
+ * @ingroup Test
+ *
+ * @group ORM
+ *
+ * The database group has as a side effect that temporal database tables are created. This makes
+ * it possible to test without poisoning a production database.
+ * @group Database
+ *
+ * Some of the tests takes more time, and needs therefor longer time before they can be aborted
+ * as non-functional. The reason why tests are aborted is assumed to be set up of temporal databases
+ * that hold the first tests in a pending state awaiting access to the database.
+ * @group medium
+ *
+ * @licence GNU GPL v2+
+ * @author Jeroen De Dauw < jeroendedauw@gmail.com >
+ */
+abstract class ORMRowTest extends \MediaWikiTestCase {
+
+	/**
+	 * @since 1.20
+	 * @return string
+	 */
+	abstract protected function getRowClass();
+
+	/**
+	 * @since 1.20
+	 * @return IORMTable
+	 */
+	abstract protected function getTableInstance();
+
+	/**
+	 * @since 1.20
+	 * @return array
+	 */
+	abstract public function constructorTestProvider();
+
+	/**
+	 * @since 1.20
+	 * @param IORMRow $row
+	 * @param array $data
+	 */
+	protected function verifyFields( IORMRow $row, array $data ) {
+		foreach ( array_keys( $data ) as $fieldName ) {
+			$this->assertEquals( $data[$fieldName], $row->getField( $fieldName ) );
+		}
+	}
+
+	/**
+	 * @since 1.20
+	 * @param array $data
+	 * @param boolean $loadDefaults
+	 * @return IORMRow
+	 */
+	protected function getRowInstance( array $data, $loadDefaults ) {
+		$class = $this->getRowClass();
+		return new $class( $this->getTableInstance(), $data, $loadDefaults );
+	}
+
+	/**
+	 * @since 1.20
+	 * @return array
+	 */
+	protected function getMockValues() {
+		return array(
+			'id' => 1,
+			'str' => 'foobar4645645',
+			'int' => 42,
+			'float' => 4.2,
+			'bool' => true,
+			'array' => array( 42, 'foobar' ),
+			'blob' => new stdClass()
+		);
+	}
+
+	/**
+	 * @since 1.20
+	 * @return array
+	 */
+	protected function getMockFields() {
+		$mockValues = $this->getMockValues();
+		$mockFields = array();
+
+		foreach ( $this->getTableInstance()->getFields() as $name => $type ) {
+			if ( $name !== 'id' ) {
+				$mockFields[$name] = $mockValues[$type];
+			}
+		}
+
+		return $mockFields;
+	}
+
+	/**
+	 * @since 1.20
+	 * @return array of IORMRow
+	 */
+	public function instanceProvider() {
+		$instances = array();
+
+		foreach ( $this->constructorTestProvider() as $arguments ) {
+			$instances[] = array( call_user_func_array( array( $this, 'getRowInstance' ), $arguments ) );
+		}
+
+		return $instances;
+	}
+
+	/**
+	 * @dataProvider constructorTestProvider
+	 */
+	public function testConstructor( array $data, $loadDefaults ) {
+		$this->verifyFields( $this->getRowInstance( $data, $loadDefaults ), $data );
+	}
+
+	/**
+	 * @dataProvider constructorTestProvider
+	 */
+	public function testSaveAndRemove( array $data, $loadDefaults ) {
+		$item = $this->getRowInstance( $data, $loadDefaults );
+
+		$this->assertTrue( $item->save() );
+
+		$this->assertTrue( $item->hasIdField() );
+		$this->assertTrue( is_integer( $item->getId() ) );
+
+		$id = $item->getId();
+
+		$this->assertTrue( $item->save() );
+
+		$this->assertEquals( $id, $item->getId() );
+
+		$this->verifyFields( $item, $data );
+
+		$this->assertTrue( $item->remove() );
+
+		$this->assertFalse( $item->hasIdField() );
+
+		$this->assertTrue( $item->save() );
+
+		$this->verifyFields( $item, $data );
+
+		$this->assertTrue( $item->remove() );
+
+		$this->assertFalse( $item->hasIdField() );
+
+		$this->verifyFields( $item, $data );
+	}
+
+	/**
+	 * @dataProvider instanceProvider
+	 */
+	public function testSetField( IORMRow $item ) {
+		foreach ( $this->getMockFields() as $name => $value ) {
+			$item->setField( $name, $value );
+			$this->assertEquals( $value, $item->getField( $name ) );
+		}
+	}
+
+	/**
+	 * @since 1.20
+	 * @param array $expected
+	 * @param IORMRow $item
+	 */
+	protected function assertFieldValues( array $expected, IORMRow $item ) {
+		foreach ( $expected as $name => $type ) {
+			if ( $name !== 'id' ) {
+				$this->assertEquals( $expected[$name], $item->getField( $name ) );
+			}
+		}
+	}
+
+	/**
+	 * @dataProvider instanceProvider
+	 */
+	public function testSetFields( IORMRow $item ) {
+		$originalValues = $item->getFields();
+
+		$item->setFields( array(), false );
+
+		foreach ( $item->getTable()->getFields() as $name => $type ) {
+			$originalHas = array_key_exists( $name, $originalValues );
+			$newHas = $item->hasField( $name );
+
+			$this->assertEquals( $originalHas, $newHas );
+
+			if ( $originalHas && $newHas ) {
+				$this->assertEquals( $originalValues[$name], $item->getField( $name ) );
+			}
+		}
+
+		$mockFields = $this->getMockFields();
+
+		$item->setFields( $mockFields, false );
+
+		$this->assertFieldValues( $originalValues, $item );
+
+		$item->setFields( $mockFields, true );
+
+		$this->assertFieldValues( $mockFields, $item );
+	}
+
+	// TODO: test all of the methods!
+
+}
diff --git a/tests/phpunit/includes/db/ORMTableTest.php b/tests/phpunit/includes/db/ORMTableTest.php
new file mode 100644
index 00000000..4cadf31c
--- /dev/null
+++ b/tests/phpunit/includes/db/ORMTableTest.php
@@ -0,0 +1,146 @@
+<?php
+/**
+ * Abstract class to construct tests for ORMTable deriving classes.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * http://www.gnu.org/copyleft/gpl.html
+ *
+ * @file
+ * @since 1.21
+ *
+ * @ingroup Test
+ *
+ * @group ORM
+ * @group Database
+ *
+ * @licence GNU GPL v2+
+ * @author Jeroen De Dauw < jeroendedauw@gmail.com >
+ * @author Daniel Kinzler
+ */
+class ORMTableTest extends MediaWikiTestCase {
+
+	/**
+	 * @since 1.21
+	 * @return string
+	 */
+	protected function getTableClass() {
+		return 'PageORMTableForTesting';
+	}
+
+	/**
+	 * @since 1.21
+	 * @return IORMTable
+	 */
+	public function getTable() {
+		$class = $this->getTableClass();
+		return $class::singleton();
+	}
+
+	/**
+	 * @since 1.21
+	 * @return string
+	 */
+	public function getRowClass() {
+		return $this->getTable()->getRowClass();
+	}
+
+	/**
+	 * @since 1.21
+	 */
+	public function testSingleton() {
+		$class = $this->getTableClass();
+
+		$this->assertInstanceOf( $class, $class::singleton() );
+		$this->assertTrue( $class::singleton() === $class::singleton() );
+	}
+
+	/**
+	 * @since 1.21
+	 */
+	public function testIgnoreErrorsOverride() {
+		$table = $this->getTable();
+
+		$db = $table->getReadDbConnection();
+		$db->ignoreErrors( true );
+
+		try {
+			$table->rawSelect( "this is invalid" );
+			$this->fail( "An invalid query should trigger a DBQueryError even if ignoreErrors is enabled." );
+		} catch ( DBQueryError $ex ) {
+			$this->assertTrue( true, "just making phpunit happy" );
+		}
+
+		$db->ignoreErrors( false );
+	}
+
+}
+
+/**
+ * Dummy ORM table for testing, reading Title objects from the page table.
+ *
+ * @since 1.21
+ */
+
+class PageORMTableForTesting extends ORMTable {
+
+	/**
+	 * @see ORMTable::getName
+	 *
+	 * @return string
+	 */
+	public function getName() {
+		return 'page';
+	}
+
+	/**
+	 * @see ORMTable::getRowClass
+	 *
+	 * @return string
+	 */
+	public function getRowClass() {
+		return 'Title';
+	}
+
+	/**
+	 * @see ORMTable::newRow
+	 *
+	 * @return IORMRow
+	 */
+	public function newRow( array $data, $loadDefaults = false ) {
+		return Title::makeTitle( $data['namespace'], $data['title'] );
+	}
+
+	/**
+	 * @see ORMTable::getFields
+	 *
+	 * @return array
+	 */
+	public function getFields() {
+		return array(
+			'id' => 'int',
+			'namespace' => 'int',
+			'title' => 'str',
+		);
+	}
+
+	/**
+	 * @see ORMTable::getFieldPrefix
+	 *
+	 * @return string
+	 */
+	protected function getFieldPrefix() {
+		return 'page_';
+	}
+}
diff --git a/tests/phpunit/includes/db/TestORMRowTest.php b/tests/phpunit/includes/db/TestORMRowTest.php
new file mode 100644
index 00000000..263553ac
--- /dev/null
+++ b/tests/phpunit/includes/db/TestORMRowTest.php
@@ -0,0 +1,199 @@
+<?php
+
+/**
+ * Tests for the TestORMRow class.
+ * TestORMRow is a dummy class to be able to test the abstract ORMRow class.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * http://www.gnu.org/copyleft/gpl.html
+ *
+ * @file
+ * @since 1.20
+ *
+ * @ingroup Test
+ *
+ * @group ORM
+ *
+ * The database group has as a side effect that temporal database tables are created. This makes
+ * it possible to test without poisoning a production database.
+ * @group Database
+ *
+ * Some of the tests takes more time, and needs therefor longer time before they can be aborted
+ * as non-functional. The reason why tests are aborted is assumed to be set up of temporal databases
+ * that hold the first tests in a pending state awaiting access to the database.
+ * @group medium
+ *
+ * @licence GNU GPL v2+
+ * @author Jeroen De Dauw < jeroendedauw@gmail.com >
+ */
+require_once __DIR__ . "/ORMRowTest.php";
+
+class TestORMRowTest extends ORMRowTest {
+
+	/**
+	 * @since 1.20
+	 * @return string
+	 */
+	protected function getRowClass() {
+		return 'TestORMRow';
+	}
+
+	/**
+	 * @since 1.20
+	 * @return IORMTable
+	 */
+	protected function getTableInstance() {
+		return TestORMTable::singleton();
+	}
+
+	protected function setUp() {
+		parent::setUp();
+
+		$dbw = wfGetDB( DB_MASTER );
+
+		$isSqlite = $GLOBALS['wgDBtype'] === 'sqlite';
+
+		$idField = $isSqlite ? 'INTEGER' : 'INT unsigned';
+		$primaryKey = $isSqlite ? 'PRIMARY KEY AUTOINCREMENT' : 'auto_increment PRIMARY KEY';
+
+		$dbw->query(
+			'CREATE TABLE IF NOT EXISTS ' . $dbw->tableName( 'orm_test' ) . '(
+				test_id                    ' . $idField . '        NOT NULL ' . $primaryKey . ',
+				test_name                  VARCHAR(255)        NOT NULL,
+				test_age                   TINYINT unsigned    NOT NULL,
+				test_height                FLOAT               NOT NULL,
+				test_awesome               TINYINT unsigned    NOT NULL,
+				test_stuff                 BLOB                NOT NULL,
+				test_moarstuff             BLOB                NOT NULL,
+				test_time                  varbinary(14)       NOT NULL
+			);',
+			__METHOD__
+		);
+	}
+
+	protected function tearDown() {
+		$dbw = wfGetDB( DB_MASTER );
+		$dbw->dropTable( 'orm_test', __METHOD__ );
+
+		parent::tearDown();
+	}
+
+	public function constructorTestProvider() {
+		return array(
+			array(
+				array(
+					'name' => 'Foobar',
+					'time' => '20120101020202',
+					'age' => 42,
+					'height' => 9000.1,
+					'awesome' => true,
+					'stuff' => array( 13, 11, 7, 5, 3, 2 ),
+					'moarstuff' => (object)array( 'foo' => 'bar', 'bar' => array( 4, 2 ), 'baz' => true )
+				),
+				true
+			),
+		);
+	}
+
+	/**
+	 * @since 1.21
+	 * @return array
+	 */
+	protected function getMockValues() {
+		return array(
+			'id' => 1,
+			'str' => 'foobar4645645',
+			'int' => 42,
+			'float' => 4.2,
+			'bool' => '',
+			'array' => array( 42, 'foobar' ),
+			'blob' => new stdClass()
+		);
+	}
+
+}
+
+class TestORMRow extends ORMRow {}
+
+class TestORMTable extends ORMTable {
+
+	/**
+	 * Returns the name of the database table objects of this type are stored in.
+	 *
+	 * @since 1.20
+	 *
+	 * @return string
+	 */
+	public function getName() {
+		return 'orm_test';
+	}
+
+	/**
+	 * Returns the name of a IORMRow implementing class that
+	 * represents single rows in this table.
+	 *
+	 * @since 1.20
+	 *
+	 * @return string
+	 */
+	public function getRowClass() {
+		return 'TestORMRow';
+	}
+
+	/**
+	 * Returns an array with the fields and their types this object contains.
+	 * This corresponds directly to the fields in the database, without prefix.
+	 *
+	 * field name => type
+	 *
+	 * Allowed types:
+	 * * id
+	 * * str
+	 * * int
+	 * * float
+	 * * bool
+	 * * array
+	 * * blob
+	 *
+	 * @since 1.20
+	 *
+	 * @return array
+	 */
+	public function getFields() {
+		return array(
+			'id' => 'id',
+			'name' => 'str',
+			'age' => 'int',
+			'height' => 'float',
+			'awesome' => 'bool',
+			'stuff' => 'array',
+			'moarstuff' => 'blob',
+			'time' => 'str', // TS_MW
+		);
+	}
+
+	/**
+	 * Gets the db field prefix.
+	 *
+	 * @since 1.20
+	 *
+	 * @return string
+	 */
+	protected function getFieldPrefix() {
+		return 'test_';
+	}
+
+
+}