tests/phpunit/includes/libs/rdbms/database/DatabaseTest.php

   1 <?php
   2
   3 use Wikimedia\Rdbms\Database;
   4 use Wikimedia\Rdbms\IDatabase;
   5 use Wikimedia\Rdbms\DatabaseMysqli;
   6 use Wikimedia\Rdbms\LBFactorySingle;
   7 use Wikimedia\Rdbms\TransactionProfiler;
   8 use Wikimedia\TestingAccessWrapper;
   9 use Wikimedia\Rdbms\DatabaseSqlite;
  10 use Wikimedia\Rdbms\DatabasePostgres;
  11 use Wikimedia\Rdbms\DatabaseMssql;
  12
  13 class DatabaseTest extends PHPUnit\Framework\TestCase {
  14
  15         use MediaWikiCoversValidator;
  16
  17         protected function setUp() {
  18                 $this->db = new DatabaseTestHelper( __CLASS__ . '::' . $this->getName() );
  19         }
  20
  21         /**
  22          * @dataProvider provideAddQuotes
  23          * @covers Wikimedia\Rdbms\Database::factory
  24          */
  25         public function testFactory() {
  26                 $m = Database::NEW_UNCONNECTED; // no-connect mode
  27                 $p = [ 'host' => 'localhost', 'user' => 'me', 'password' => 'myself', 'dbname' => 'i' ];
  28
  29                 $this->assertInstanceOf( DatabaseMysqli::class, Database::factory( 'mysqli', $p, $m ) );
  30                 $this->assertInstanceOf( DatabaseMysqli::class, Database::factory( 'MySqli', $p, $m ) );
  31                 $this->assertInstanceOf( DatabaseMysqli::class, Database::factory( 'MySQLi', $p, $m ) );
  32                 $this->assertInstanceOf( DatabasePostgres::class, Database::factory( 'postgres', $p, $m ) );
  33                 $this->assertInstanceOf( DatabasePostgres::class, Database::factory( 'Postgres', $p, $m ) );
  34
  35                 $x = $p + [ 'port' => 10000, 'UseWindowsAuth' => false ];
  36                 $this->assertInstanceOf( DatabaseMssql::class, Database::factory( 'mssql', $x, $m ) );
  37
  38                 $x = $p + [ 'dbFilePath' => 'some/file.sqlite' ];
  39                 $this->assertInstanceOf( DatabaseSqlite::class, Database::factory( 'sqlite', $x, $m ) );
  40                 $x = $p + [ 'dbDirectory' => 'some/file' ];
  41                 $this->assertInstanceOf( DatabaseSqlite::class, Database::factory( 'sqlite', $x, $m ) );
  42         }
  43
  44         public static function provideAddQuotes() {
  45                 return [
  46                         [ null, 'NULL' ],
  47                         [ 1234, "'1234'" ],
  48                         [ 1234.5678, "'1234.5678'" ],
  49                         [ 'string', "'string'" ],
  50                         [ 'string\'s cause trouble', "'string\'s cause trouble'" ],
  51                 ];
  52         }
  53
  54         /**
  55          * @dataProvider provideAddQuotes
  56          * @covers Wikimedia\Rdbms\Database::addQuotes
  57          */
  58         public function testAddQuotes( $input, $expected ) {
  59                 $this->assertEquals( $expected, $this->db->addQuotes( $input ) );
  60         }
  61
  62         public static function provideTableName() {
  63                 // Formatting is mostly ignored since addIdentifierQuotes is abstract.
  64                 // For testing of addIdentifierQuotes, see actual Database subclas tests.
  65                 return [
  66                         'local' => [
  67                                 'tablename',
  68                                 'tablename',
  69                                 'quoted',
  70                         ],
  71                         'local-raw' => [
  72                                 'tablename',
  73                                 'tablename',
  74                                 'raw',
  75                         ],
  76                         'shared' => [
  77                                 'sharedb.tablename',
  78                                 'tablename',
  79                                 'quoted',
  80                                 [ 'dbname' => 'sharedb', 'schema' => null, 'prefix' => '' ],
  81                         ],
  82                         'shared-raw' => [
  83                                 'sharedb.tablename',
  84                                 'tablename',
  85                                 'raw',
  86                                 [ 'dbname' => 'sharedb', 'schema' => null, 'prefix' => '' ],
  87                         ],
  88                         'shared-prefix' => [
  89                                 'sharedb.sh_tablename',
  90                                 'tablename',
  91                                 'quoted',
  92                                 [ 'dbname' => 'sharedb', 'schema' => null, 'prefix' => 'sh_' ],
  93                         ],
  94                         'shared-prefix-raw' => [
  95                                 'sharedb.sh_tablename',
  96                                 'tablename',
  97                                 'raw',
  98                                 [ 'dbname' => 'sharedb', 'schema' => null, 'prefix' => 'sh_' ],
  99                         ],
 100                         'foreign' => [
 101                                 'databasename.tablename',
 102                                 'databasename.tablename',
 103                                 'quoted',
 104                         ],
 105                         'foreign-raw' => [
 106                                 'databasename.tablename',
 107                                 'databasename.tablename',
 108                                 'raw',
 109                         ],
 110                 ];
 111         }
 112
 113         /**
 114          * @dataProvider provideTableName
 115          * @covers Wikimedia\Rdbms\Database::tableName
 116          */
 117         public function testTableName( $expected, $table, $format, array $alias = null ) {
 118                 if ( $alias ) {
 119                         $this->db->setTableAliases( [ $table => $alias ] );
 120                 }
 121                 $this->assertEquals(
 122                         $expected,
 123                         $this->db->tableName( $table, $format ?: 'quoted' )
 124                 );
 125         }
 126
 127         public function provideTableNamesWithIndexClauseOrJOIN() {
 128                 return [
 129                         'one-element array' => [
 130                                 [ 'table' ], [], 'table '
 131                         ],
 132                         'comma join' => [
 133                                 [ 'table1', 'table2' ], [], 'table1,table2 '
 134                         ],
 135                         'real join' => [
 136                                 [ 'table1', 'table2' ],
 137                                 [ 'table2' => [ 'LEFT JOIN', 't1_id = t2_id' ] ],
 138                                 'table1 LEFT JOIN table2 ON ((t1_id = t2_id))'
 139                         ],
 140                         'real join with multiple conditionals' => [
 141                                 [ 'table1', 'table2' ],
 142                                 [ 'table2' => [ 'LEFT JOIN', [ 't1_id = t2_id', 't2_x = \'X\'' ] ] ],
 143                                 'table1 LEFT JOIN table2 ON ((t1_id = t2_id) AND (t2_x = \'X\'))'
 144                         ],
 145                         'join with parenthesized group' => [
 146                                 [ 'table1', 'n' => [ 'table2', 'table3' ] ],
 147                                 [
 148                                         'table3' => [ 'JOIN', 't2_id = t3_id' ],
 149                                         'n' => [ 'LEFT JOIN', 't1_id = t2_id' ],
 150                                 ],
 151                                 'table1 LEFT JOIN (table2 JOIN table3 ON ((t2_id = t3_id))) ON ((t1_id = t2_id))'
 152                         ],
 153                         'join with degenerate parenthesized group' => [
 154                                 [ 'table1', 'n' => [ 't2' => 'table2' ] ],
 155                                 [
 156                                         'n' => [ 'LEFT JOIN', 't1_id = t2_id' ],
 157                                 ],
 158                                 'table1 LEFT JOIN table2 t2 ON ((t1_id = t2_id))'
 159                         ],
 160                 ];
 161         }
 162
 163         /**
 164          * @dataProvider provideTableNamesWithIndexClauseOrJOIN
 165          * @covers Wikimedia\Rdbms\Database::tableNamesWithIndexClauseOrJOIN
 166          */
 167         public function testTableNamesWithIndexClauseOrJOIN( $tables, $join_conds, $expect ) {
 168                 $clause = TestingAccessWrapper::newFromObject( $this->db )
 169                         ->tableNamesWithIndexClauseOrJOIN( $tables, [], [], $join_conds );
 170                 $this->assertSame( $expect, $clause );
 171         }
 172
 173         /**
 174          * @covers Wikimedia\Rdbms\Database::onTransactionIdle
 175          * @covers Wikimedia\Rdbms\Database::runOnTransactionIdleCallbacks
 176          */
 177         public function testTransactionIdle() {
 178                 $db = $this->db;
 179
 180                 $db->clearFlag( DBO_TRX );
 181                 $called = false;
 182                 $flagSet = null;
 183                 $callback = function () use ( $db, &$flagSet, &$called ) {
 184                         $called = true;
 185                         $flagSet = $db->getFlag( DBO_TRX );
 186                 };
 187
 188                 $db->onTransactionIdle( $callback, __METHOD__ );
 189                 $this->assertTrue( $called, 'Callback reached' );
 190                 $this->assertFalse( $flagSet, 'DBO_TRX off in callback' );
 191                 $this->assertFalse( $db->getFlag( DBO_TRX ), 'DBO_TRX still default' );
 192
 193                 $flagSet = null;
 194                 $called = false;
 195                 $db->startAtomic( __METHOD__ );
 196                 $db->onTransactionIdle( $callback, __METHOD__ );
 197                 $this->assertFalse( $called, 'Callback not reached during TRX' );
 198                 $db->endAtomic( __METHOD__ );
 199
 200                 $this->assertTrue( $called, 'Callback reached after COMMIT' );
 201                 $this->assertFalse( $flagSet, 'DBO_TRX off in callback' );
 202                 $this->assertFalse( $db->getFlag( DBO_TRX ), 'DBO_TRX restored to default' );
 203
 204                 $db->clearFlag( DBO_TRX );
 205                 $db->onTransactionIdle(
 206                         function () use ( $db ) {
 207                                 $db->setFlag( DBO_TRX );
 208                         },
 209                         __METHOD__
 210                 );
 211                 $this->assertFalse( $db->getFlag( DBO_TRX ), 'DBO_TRX restored to default' );
 212         }
 213
 214         /**
 215          * @covers Wikimedia\Rdbms\Database::onTransactionIdle
 216          * @covers Wikimedia\Rdbms\Database::runOnTransactionIdleCallbacks
 217          */
 218         public function testTransactionIdle_TRX() {
 219                 $db = $this->getMockDB( [ 'isOpen', 'ping' ] );
 220                 $db->method( 'isOpen' )->willReturn( true );
 221                 $db->method( 'ping' )->willReturn( true );
 222                 $db->setFlag( DBO_TRX );
 223
 224                 $lbFactory = LBFactorySingle::newFromConnection( $db );
 225                 // Ask for the connection so that LB sets internal state
 226                 // about this connection being the master connection
 227                 $lb = $lbFactory->getMainLB();
 228                 $conn = $lb->openConnection( $lb->getWriterIndex() );
 229                 $this->assertSame( $db, $conn, 'Same DB instance' );
 230                 $this->assertTrue( $db->getFlag( DBO_TRX ), 'DBO_TRX is set' );
 231
 232                 $called = false;
 233                 $flagSet = null;
 234                 $callback = function () use ( $db, &$flagSet, &$called ) {
 235                         $called = true;
 236                         $flagSet = $db->getFlag( DBO_TRX );
 237                 };
 238
 239                 $db->onTransactionIdle( $callback, __METHOD__ );
 240                 $this->assertTrue( $called, 'Called when idle if DBO_TRX is set' );
 241                 $this->assertFalse( $flagSet, 'DBO_TRX off in callback' );
 242                 $this->assertTrue( $db->getFlag( DBO_TRX ), 'DBO_TRX still default' );
 243
 244                 $called = false;
 245                 $lbFactory->beginMasterChanges( __METHOD__ );
 246                 $db->onTransactionIdle( $callback, __METHOD__ );
 247                 $this->assertFalse( $called, 'Not called when lb-transaction is active' );
 248
 249                 $lbFactory->commitMasterChanges( __METHOD__ );
 250                 $this->assertTrue( $called, 'Called when lb-transaction is committed' );
 251
 252                 $called = false;
 253                 $lbFactory->beginMasterChanges( __METHOD__ );
 254                 $db->onTransactionIdle( $callback, __METHOD__ );
 255                 $this->assertFalse( $called, 'Not called when lb-transaction is active' );
 256
 257                 $lbFactory->rollbackMasterChanges( __METHOD__ );
 258                 $this->assertFalse( $called, 'Not called when lb-transaction is rolled back' );
 259
 260                 $lbFactory->commitMasterChanges( __METHOD__ );
 261                 $this->assertFalse( $called, 'Not called in next round commit' );
 262         }
 263
 264         /**
 265          * @covers Wikimedia\Rdbms\Database::onTransactionPreCommitOrIdle
 266          * @covers Wikimedia\Rdbms\Database::runOnTransactionPreCommitCallbacks
 267          */
 268         public function testTransactionPreCommitOrIdle() {
 269                 $db = $this->getMockDB( [ 'isOpen' ] );
 270                 $db->method( 'isOpen' )->willReturn( true );
 271                 $db->clearFlag( DBO_TRX );
 272
 273                 $this->assertFalse( $db->getFlag( DBO_TRX ), 'DBO_TRX is not set' );
 274
 275                 $called = false;
 276                 $db->onTransactionPreCommitOrIdle(
 277                         function () use ( &$called ) {
 278                                 $called = true;
 279                         },
 280                         __METHOD__
 281                 );
 282                 $this->assertTrue( $called, 'Called when idle' );
 283
 284                 $db->begin( __METHOD__ );
 285                 $called = false;
 286                 $db->onTransactionPreCommitOrIdle(
 287                         function () use ( &$called ) {
 288                                 $called = true;
 289                         },
 290                         __METHOD__
 291                 );
 292                 $this->assertFalse( $called, 'Not called when transaction is active' );
 293                 $db->commit( __METHOD__ );
 294                 $this->assertTrue( $called, 'Called when transaction is committed' );
 295         }
 296
 297         /**
 298          * @covers Wikimedia\Rdbms\Database::onTransactionPreCommitOrIdle
 299          * @covers Wikimedia\Rdbms\Database::runOnTransactionPreCommitCallbacks
 300          */
 301         public function testTransactionPreCommitOrIdle_TRX() {
 302                 $db = $this->getMockDB( [ 'isOpen', 'ping' ] );
 303                 $db->method( 'isOpen' )->willReturn( true );
 304                 $db->method( 'ping' )->willReturn( true );
 305                 $db->setFlag( DBO_TRX );
 306
 307                 $lbFactory = LBFactorySingle::newFromConnection( $db );
 308                 // Ask for the connection so that LB sets internal state
 309                 // about this connection being the master connection
 310                 $lb = $lbFactory->getMainLB();
 311                 $conn = $lb->openConnection( $lb->getWriterIndex() );
 312                 $this->assertSame( $db, $conn, 'Same DB instance' );
 313                 $this->assertTrue( $db->getFlag( DBO_TRX ), 'DBO_TRX is set' );
 314
 315                 $called = false;
 316                 $callback = function () use ( &$called ) {
 317                         $called = true;
 318                 };
 319                 $db->onTransactionPreCommitOrIdle( $callback, __METHOD__ );
 320                 $this->assertTrue( $called, 'Called when idle if DBO_TRX is set' );
 321
 322                 $called = false;
 323                 $lbFactory->beginMasterChanges( __METHOD__ );
 324                 $db->onTransactionPreCommitOrIdle( $callback, __METHOD__ );
 325                 $this->assertFalse( $called, 'Not called when lb-transaction is active' );
 326                 $lbFactory->commitMasterChanges( __METHOD__ );
 327                 $this->assertTrue( $called, 'Called when lb-transaction is committed' );
 328
 329                 $called = false;
 330                 $lbFactory->beginMasterChanges( __METHOD__ );
 331                 $db->onTransactionPreCommitOrIdle( $callback, __METHOD__ );
 332                 $this->assertFalse( $called, 'Not called when lb-transaction is active' );
 333
 334                 $lbFactory->rollbackMasterChanges( __METHOD__ );
 335                 $this->assertFalse( $called, 'Not called when lb-transaction is rolled back' );
 336
 337                 $lbFactory->commitMasterChanges( __METHOD__ );
 338                 $this->assertFalse( $called, 'Not called in next round commit' );
 339         }
 340
 341         /**
 342          * @covers Wikimedia\Rdbms\Database::onTransactionResolution
 343          * @covers Wikimedia\Rdbms\Database::runOnTransactionIdleCallbacks
 344          */
 345         public function testTransactionResolution() {
 346                 $db = $this->db;
 347
 348                 $db->clearFlag( DBO_TRX );
 349                 $db->begin( __METHOD__ );
 350                 $called = false;
 351                 $db->onTransactionResolution( function () use ( $db, &$called ) {
 352                         $called = true;
 353                         $db->setFlag( DBO_TRX );
 354                 } );
 355                 $db->commit( __METHOD__ );
 356                 $this->assertFalse( $db->getFlag( DBO_TRX ), 'DBO_TRX restored to default' );
 357                 $this->assertTrue( $called, 'Callback reached' );
 358
 359                 $db->clearFlag( DBO_TRX );
 360                 $db->begin( __METHOD__ );
 361                 $called = false;
 362                 $db->onTransactionResolution( function () use ( $db, &$called ) {
 363                         $called = true;
 364                         $db->setFlag( DBO_TRX );
 365                 } );
 366                 $db->rollback( __METHOD__, IDatabase::FLUSHING_ALL_PEERS );
 367                 $this->assertFalse( $db->getFlag( DBO_TRX ), 'DBO_TRX restored to default' );
 368                 $this->assertTrue( $called, 'Callback reached' );
 369         }
 370
 371         /**
 372          * @covers Wikimedia\Rdbms\Database::setTransactionListener
 373          */
 374         public function testTransactionListener() {
 375                 $db = $this->db;
 376
 377                 $db->setTransactionListener( 'ping', function () use ( $db, &$called ) {
 378                         $called = true;
 379                 } );
 380
 381                 $called = false;
 382                 $db->begin( __METHOD__ );
 383                 $db->commit( __METHOD__ );
 384                 $this->assertTrue( $called, 'Callback reached' );
 385
 386                 $called = false;
 387                 $db->begin( __METHOD__ );
 388                 $db->commit( __METHOD__ );
 389                 $this->assertTrue( $called, 'Callback still reached' );
 390
 391                 $called = false;
 392                 $db->begin( __METHOD__ );
 393                 $db->rollback( __METHOD__ );
 394                 $this->assertTrue( $called, 'Callback reached' );
 395
 396                 $db->setTransactionListener( 'ping', null );
 397                 $called = false;
 398                 $db->begin( __METHOD__ );
 399                 $db->commit( __METHOD__ );
 400                 $this->assertFalse( $called, 'Callback not reached' );
 401         }
 402
 403         /**
 404          * Use this mock instead of DatabaseTestHelper for cases where
 405          * DatabaseTestHelper is too inflexibile due to mocking too much
 406          * or being too restrictive about fname matching (e.g. for tests
 407          * that assert behaviour when the name is a mismatch, we need to
 408          * catch the error here instead of there).
 409          *
 410          * @return Database
 411          */
 412         private function getMockDB( $methods = [] ) {
 413                 static $abstractMethods = [
 414                         'fetchAffectedRowCount',
 415                         'closeConnection',
 416                         'dataSeek',
 417                         'doQuery',
 418                         'fetchObject', 'fetchRow',
 419                         'fieldInfo', 'fieldName',
 420                         'getSoftwareLink', 'getServerVersion',
 421                         'getType',
 422                         'indexInfo',
 423                         'insertId',
 424                         'lastError', 'lastErrno',
 425                         'numFields', 'numRows',
 426                         'open',
 427                         'strencode',
 428                 ];
 429                 $db = $this->getMockBuilder( Database::class )
 430                         ->disableOriginalConstructor()
 431                         ->setMethods( array_values( array_unique( array_merge(
 432                                 $abstractMethods,
 433                                 $methods
 434                         ) ) ) )
 435                         ->getMock();
 436                 $wdb = TestingAccessWrapper::newFromObject( $db );
 437                 $wdb->trxProfiler = new TransactionProfiler();
 438                 $wdb->connLogger = new \Psr\Log\NullLogger();
 439                 $wdb->queryLogger = new \Psr\Log\NullLogger();
 440                 return $db;
 441         }
 442
 443         /**
 444          * @covers Wikimedia\Rdbms\Database::flushSnapshot
 445          */
 446         public function testFlushSnapshot() {
 447                 $db = $this->getMockDB( [ 'isOpen' ] );
 448                 $db->method( 'isOpen' )->willReturn( true );
 449
 450                 $db->flushSnapshot( __METHOD__ ); // ok
 451                 $db->flushSnapshot( __METHOD__ ); // ok
 452
 453                 $db->setFlag( DBO_TRX, $db::REMEMBER_PRIOR );
 454                 $db->query( 'SELECT 1', __METHOD__ );
 455                 $this->assertTrue( (bool)$db->trxLevel(), "Transaction started." );
 456                 $db->flushSnapshot( __METHOD__ ); // ok
 457                 $db->restoreFlags( $db::RESTORE_PRIOR );
 458
 459                 $this->assertFalse( (bool)$db->trxLevel(), "Transaction cleared." );
 460         }
 461
 462         /**
 463          * @covers Wikimedia\Rdbms\Database::getScopedLockAndFlush
 464          * @covers Wikimedia\Rdbms\Database::lock
 465          * @covers Wikimedia\Rdbms\Database::unlock
 466          * @covers Wikimedia\Rdbms\Database::lockIsFree
 467          */
 468         public function testGetScopedLock() {
 469                 $db = $this->getMockDB( [ 'isOpen' ] );
 470                 $db->method( 'isOpen' )->willReturn( true );
 471
 472                 $this->assertEquals( 0, $db->trxLevel() );
 473                 $this->assertEquals( true, $db->lockIsFree( 'x', __METHOD__ ) );
 474                 $this->assertEquals( true, $db->lock( 'x', __METHOD__ ) );
 475                 $this->assertEquals( false, $db->lockIsFree( 'x', __METHOD__ ) );
 476                 $this->assertEquals( true, $db->unlock( 'x', __METHOD__ ) );
 477                 $this->assertEquals( true, $db->lockIsFree( 'x', __METHOD__ ) );
 478                 $this->assertEquals( 0, $db->trxLevel() );
 479
 480                 $db->setFlag( DBO_TRX );
 481                 $this->assertEquals( true, $db->lockIsFree( 'x', __METHOD__ ) );
 482                 $this->assertEquals( true, $db->lock( 'x', __METHOD__ ) );
 483                 $this->assertEquals( false, $db->lockIsFree( 'x', __METHOD__ ) );
 484                 $this->assertEquals( true, $db->unlock( 'x', __METHOD__ ) );
 485                 $this->assertEquals( true, $db->lockIsFree( 'x', __METHOD__ ) );
 486                 $db->clearFlag( DBO_TRX );
 487
 488                 $this->assertEquals( 0, $db->trxLevel() );
 489
 490                 $db->setFlag( DBO_TRX );
 491                 try {
 492                         $this->badLockingMethodImplicit( $db );
 493                 } catch ( RunTimeException $e ) {
 494                         $this->assertTrue( $db->trxLevel() > 0, "Transaction not committed." );
 495                 }
 496                 $db->clearFlag( DBO_TRX );
 497                 $db->rollback( __METHOD__, IDatabase::FLUSHING_ALL_PEERS );
 498                 $this->assertTrue( $db->lockIsFree( 'meow', __METHOD__ ) );
 499
 500                 try {
 501                         $this->badLockingMethodExplicit( $db );
 502                 } catch ( RunTimeException $e ) {
 503                         $this->assertTrue( $db->trxLevel() > 0, "Transaction not committed." );
 504                 }
 505                 $db->rollback( __METHOD__, IDatabase::FLUSHING_ALL_PEERS );
 506                 $this->assertTrue( $db->lockIsFree( 'meow', __METHOD__ ) );
 507         }
 508
 509         private function badLockingMethodImplicit( IDatabase $db ) {
 510                 $lock = $db->getScopedLockAndFlush( 'meow', __METHOD__, 1 );
 511                 $db->query( "SELECT 1" ); // trigger DBO_TRX
 512                 throw new RunTimeException( "Uh oh!" );
 513         }
 514
 515         private function badLockingMethodExplicit( IDatabase $db ) {
 516                 $lock = $db->getScopedLockAndFlush( 'meow', __METHOD__, 1 );
 517                 $db->begin( __METHOD__ );
 518                 throw new RunTimeException( "Uh oh!" );
 519         }
 520
 521         /**
 522          * @covers Wikimedia\Rdbms\Database::getFlag
 523          * @covers Wikimedia\Rdbms\Database::setFlag
 524          * @covers Wikimedia\Rdbms\Database::restoreFlags
 525          */
 526         public function testFlagSetting() {
 527                 $db = $this->db;
 528                 $origTrx = $db->getFlag( DBO_TRX );
 529                 $origSsl = $db->getFlag( DBO_SSL );
 530
 531                 $origTrx
 532                         ? $db->clearFlag( DBO_TRX, $db::REMEMBER_PRIOR )
 533                         : $db->setFlag( DBO_TRX, $db::REMEMBER_PRIOR );
 534                 $this->assertEquals( !$origTrx, $db->getFlag( DBO_TRX ) );
 535
 536                 $origSsl
 537                         ? $db->clearFlag( DBO_SSL, $db::REMEMBER_PRIOR )
 538                         : $db->setFlag( DBO_SSL, $db::REMEMBER_PRIOR );
 539                 $this->assertEquals( !$origSsl, $db->getFlag( DBO_SSL ) );
 540
 541                 $db->restoreFlags( $db::RESTORE_INITIAL );
 542                 $this->assertEquals( $origTrx, $db->getFlag( DBO_TRX ) );
 543                 $this->assertEquals( $origSsl, $db->getFlag( DBO_SSL ) );
 544
 545                 $origTrx
 546                         ? $db->clearFlag( DBO_TRX, $db::REMEMBER_PRIOR )
 547                         : $db->setFlag( DBO_TRX, $db::REMEMBER_PRIOR );
 548                 $origSsl
 549                         ? $db->clearFlag( DBO_SSL, $db::REMEMBER_PRIOR )
 550                         : $db->setFlag( DBO_SSL, $db::REMEMBER_PRIOR );
 551
 552                 $db->restoreFlags();
 553                 $this->assertEquals( $origSsl, $db->getFlag( DBO_SSL ) );
 554                 $this->assertEquals( !$origTrx, $db->getFlag( DBO_TRX ) );
 555
 556                 $db->restoreFlags();
 557                 $this->assertEquals( $origSsl, $db->getFlag( DBO_SSL ) );
 558                 $this->assertEquals( $origTrx, $db->getFlag( DBO_TRX ) );
 559         }
 560
 561         /**
 562          * @expectedException UnexpectedValueException
 563          * @covers Wikimedia\Rdbms\Database::setFlag
 564          */
 565         public function testDBOIgnoreSet() {
 566                 $db = $this->getMockBuilder( DatabaseMysqli::class )
 567                         ->disableOriginalConstructor()
 568                         ->setMethods( null )
 569                         ->getMock();
 570
 571                 $db->setFlag( Database::DBO_IGNORE );
 572         }
 573
 574         /**
 575          * @expectedException UnexpectedValueException
 576          * @covers Wikimedia\Rdbms\Database::clearFlag
 577          */
 578         public function testDBOIgnoreClear() {
 579                 $db = $this->getMockBuilder( DatabaseMysqli::class )
 580                         ->disableOriginalConstructor()
 581                         ->setMethods( null )
 582                         ->getMock();
 583
 584                 $db->clearFlag( Database::DBO_IGNORE );
 585         }
 586
 587         /**
 588          * @covers Wikimedia\Rdbms\Database::tablePrefix
 589          * @covers Wikimedia\Rdbms\Database::dbSchema
 590          */
 591         public function testMutators() {
 592                 $old = $this->db->tablePrefix();
 593                 $this->assertInternalType( 'string', $old, 'Prefix is string' );
 594                 $this->assertEquals( $old, $this->db->tablePrefix(), "Prefix unchanged" );
 595                 $this->assertEquals( $old, $this->db->tablePrefix( 'xxx' ) );
 596                 $this->assertEquals( 'xxx', $this->db->tablePrefix(), "Prefix set" );
 597                 $this->db->tablePrefix( $old );
 598                 $this->assertNotEquals( 'xxx', $this->db->tablePrefix() );
 599
 600                 $old = $this->db->dbSchema();
 601                 $this->assertInternalType( 'string', $old, 'Schema is string' );
 602                 $this->assertEquals( $old, $this->db->dbSchema(), "Schema unchanged" );
 603                 $this->assertEquals( $old, $this->db->dbSchema( 'xxx' ) );
 604                 $this->assertEquals( 'xxx', $this->db->dbSchema(), "Schema set" );
 605                 $this->db->dbSchema( $old );
 606                 $this->assertNotEquals( 'xxx', $this->db->dbSchema() );
 607         }
 608 }