tests/phpunit/includes/db/LBFactoryTest.php

   1 <?php
   2 /**
   3  * Holds tests for LBFactory abstract MediaWiki class.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @file
  21  * @author Antoine Musso
  22  * @copyright © 2013 Antoine Musso
  23  * @copyright © 2013 Wikimedia Foundation Inc.
  24  */
  25
  26 use Wikimedia\AtEase\AtEase;
  27 use Wikimedia\Rdbms\IDatabase;
  28 use Wikimedia\Rdbms\IMaintainableDatabase;
  29 use Wikimedia\Rdbms\LBFactory;
  30 use Wikimedia\Rdbms\LBFactorySimple;
  31 use Wikimedia\Rdbms\LBFactoryMulti;
  32 use Wikimedia\Rdbms\LoadBalancer;
  33 use Wikimedia\Rdbms\ChronologyProtector;
  34 use Wikimedia\Rdbms\MySQLMasterPos;
  35 use Wikimedia\Rdbms\DatabaseDomain;
  36
  37 /**
  38  * @group Database
  39  * @covers \Wikimedia\Rdbms\LBFactory
  40  * @covers \Wikimedia\Rdbms\LBFactorySimple
  41  * @covers \Wikimedia\Rdbms\LBFactoryMulti
  42  */
  43 class LBFactoryTest extends MediaWikiTestCase {
  44
  45         /**
  46          * @covers MWLBFactory::getLBFactoryClass()
  47          * @dataProvider getLBFactoryClassProvider
  48          */
  49         public function testGetLBFactoryClass( $expected, $deprecated ) {
  50                 $mockDB = $this->getMockBuilder( IDatabase::class )
  51                         ->disableOriginalConstructor()
  52                         ->getMock();
  53
  54                 $config = [
  55                         'class'          => $deprecated,
  56                         'connection'     => $mockDB,
  57                         # Various other parameters required:
  58                         'sectionsByDB'   => [],
  59                         'sectionLoads'   => [],
  60                         'serverTemplate' => [],
  61                 ];
  62
  63                 $this->hideDeprecated( '$wgLBFactoryConf must be updated. See RELEASE-NOTES for details' );
  64                 $result = MWLBFactory::getLBFactoryClass( $config );
  65
  66                 $this->assertEquals( $expected, $result );
  67         }
  68
  69         public function getLBFactoryClassProvider() {
  70                 return [
  71                         # Format: new class, old class
  72                         [ Wikimedia\Rdbms\LBFactorySimple::class, 'LBFactory_Simple' ],
  73                         [ Wikimedia\Rdbms\LBFactorySingle::class, 'LBFactory_Single' ],
  74                         [ Wikimedia\Rdbms\LBFactoryMulti::class, 'LBFactory_Multi' ],
  75                         [ Wikimedia\Rdbms\LBFactorySimple::class, 'LBFactorySimple' ],
  76                         [ Wikimedia\Rdbms\LBFactorySingle::class, 'LBFactorySingle' ],
  77                         [ Wikimedia\Rdbms\LBFactoryMulti::class, 'LBFactoryMulti' ],
  78                 ];
  79         }
  80
  81         /**
  82          * @covers \Wikimedia\Rdbms\LBFactory::getLocalDomainID()
  83          * @covers \Wikimedia\Rdbms\LBFactory::resolveDomainID()
  84          */
  85         public function testLBFactorySimpleServer() {
  86                 global $wgDBserver, $wgDBname, $wgDBuser, $wgDBpassword, $wgDBtype, $wgSQLiteDataDir;
  87
  88                 $servers = [
  89                         [
  90                                 'host'        => $wgDBserver,
  91                                 'dbname'      => $wgDBname,
  92                                 'user'        => $wgDBuser,
  93                                 'password'    => $wgDBpassword,
  94                                 'type'        => $wgDBtype,
  95                                 'dbDirectory' => $wgSQLiteDataDir,
  96                                 'load'        => 0,
  97                                 'flags'       => DBO_TRX // REPEATABLE-READ for consistency
  98                         ],
  99                 ];
 100
 101                 $factory = new LBFactorySimple( [ 'servers' => $servers ] );
 102                 $lb = $factory->getMainLB();
 103
 104                 $dbw = $lb->getConnection( DB_MASTER );
 105                 $this->assertTrue( $dbw->getLBInfo( 'master' ), 'master shows as master' );
 106
 107                 $dbr = $lb->getConnection( DB_REPLICA );
 108                 $this->assertTrue( $dbr->getLBInfo( 'master' ), 'DB_REPLICA also gets the master' );
 109
 110                 $this->assertSame( 'my_test_wiki', $factory->resolveDomainID( 'my_test_wiki' ) );
 111                 $this->assertSame( $factory->getLocalDomainID(), $factory->resolveDomainID( false ) );
 112
 113                 $factory->shutdown();
 114                 $lb->closeAll();
 115         }
 116
 117         public function testLBFactorySimpleServers() {
 118                 global $wgDBserver, $wgDBname, $wgDBuser, $wgDBpassword, $wgDBtype, $wgSQLiteDataDir;
 119
 120                 $servers = [
 121                         [ // master
 122                                 'host'        => $wgDBserver,
 123                                 'dbname'      => $wgDBname,
 124                                 'user'        => $wgDBuser,
 125                                 'password'    => $wgDBpassword,
 126                                 'type'        => $wgDBtype,
 127                                 'dbDirectory' => $wgSQLiteDataDir,
 128                                 'load'        => 0,
 129                                 'flags'       => DBO_TRX // REPEATABLE-READ for consistency
 130                         ],
 131                         [ // emulated replica
 132                                 'host'        => $wgDBserver,
 133                                 'dbname'      => $wgDBname,
 134                                 'user'        => $wgDBuser,
 135                                 'password'    => $wgDBpassword,
 136                                 'type'        => $wgDBtype,
 137                                 'dbDirectory' => $wgSQLiteDataDir,
 138                                 'load'        => 100,
 139                                 'flags'       => DBO_TRX // REPEATABLE-READ for consistency
 140                         ]
 141                 ];
 142
 143                 $factory = new LBFactorySimple( [
 144                         'servers' => $servers,
 145                         'loadMonitorClass' => LoadMonitorNull::class
 146                 ] );
 147                 $lb = $factory->getMainLB();
 148
 149                 $dbw = $lb->getConnection( DB_MASTER );
 150                 $this->assertTrue( $dbw->getLBInfo( 'master' ), 'master shows as master' );
 151                 $this->assertEquals(
 152                         ( $wgDBserver != '' ) ? $wgDBserver : 'localhost',
 153                         $dbw->getLBInfo( 'clusterMasterHost' ),
 154                         'cluster master set' );
 155
 156                 $dbr = $lb->getConnection( DB_REPLICA );
 157                 $this->assertTrue( $dbr->getLBInfo( 'replica' ), 'replica shows as replica' );
 158                 $this->assertEquals(
 159                         ( $wgDBserver != '' ) ? $wgDBserver : 'localhost',
 160                         $dbr->getLBInfo( 'clusterMasterHost' ),
 161                         'cluster master set' );
 162
 163                 $factory->shutdown();
 164                 $lb->closeAll();
 165         }
 166
 167         public function testLBFactoryMultiConns() {
 168                 $factory = $this->newLBFactoryMultiLBs();
 169
 170                 $dbw = $factory->getMainLB()->getConnection( DB_MASTER );
 171                 $this->assertTrue( $dbw->getLBInfo( 'master' ), 'master shows as master' );
 172
 173                 $dbr = $factory->getMainLB()->getConnection( DB_REPLICA );
 174                 $this->assertTrue( $dbr->getLBInfo( 'replica' ), 'replica shows as replica' );
 175
 176                 // Destructor should trigger without round stage errors
 177                 unset( $factory );
 178         }
 179
 180         public function testLBFactoryMultiRoundCallbacks() {
 181                 $called = 0;
 182                 $countLBsFunc = function ( LBFactoryMulti $factory ) {
 183                         $count = 0;
 184                         $factory->forEachLB( function () use ( &$count ) {
 185                                 ++$count;
 186                         } );
 187
 188                         return $count;
 189                 };
 190
 191                 $factory = $this->newLBFactoryMultiLBs();
 192                 $this->assertEquals( 0, $countLBsFunc( $factory ) );
 193                 $dbw = $factory->getMainLB()->getConnection( DB_MASTER );
 194                 $this->assertEquals( 1, $countLBsFunc( $factory ) );
 195                 // Test that LoadBalancer instances made during pre-commit callbacks in do not
 196                 // throw DBTransactionError due to transaction ROUND_* stages being mismatched.
 197                 $factory->beginMasterChanges( __METHOD__ );
 198                 $dbw->onTransactionPreCommitOrIdle( function () use ( $factory, &$called ) {
 199                         ++$called;
 200                         // Trigger s1 LoadBalancer instantiation during "finalize" stage.
 201                         // There is no s1wiki DB to select so it is not in getConnection(),
 202                         // but this fools getMainLB() at least.
 203                         $factory->getMainLB( 's1wiki' )->getConnection( DB_MASTER );
 204                 } );
 205                 $factory->commitMasterChanges( __METHOD__ );
 206                 $this->assertEquals( 1, $called );
 207                 $this->assertEquals( 2, $countLBsFunc( $factory ) );
 208                 $factory->shutdown();
 209                 $factory->closeAll();
 210
 211                 $called = 0;
 212                 $factory = $this->newLBFactoryMultiLBs();
 213                 $this->assertEquals( 0, $countLBsFunc( $factory ) );
 214                 $dbw = $factory->getMainLB()->getConnection( DB_MASTER );
 215                 $this->assertEquals( 1, $countLBsFunc( $factory ) );
 216                 // Test that LoadBalancer instances made during pre-commit callbacks in do not
 217                 // throw DBTransactionError due to transaction ROUND_* stages being mismatched.hrow
 218                 // DBTransactionError due to transaction ROUND_* stages being mismatched.
 219                 $factory->beginMasterChanges( __METHOD__ );
 220                 $dbw->query( "SELECT 1 as t", __METHOD__ );
 221                 $dbw->onTransactionResolution( function () use ( $factory, &$called ) {
 222                         ++$called;
 223                         // Trigger s1 LoadBalancer instantiation during "finalize" stage.
 224                         // There is no s1wiki DB to select so it is not in getConnection(),
 225                         // but this fools getMainLB() at least.
 226                         $factory->getMainLB( 's1wiki' )->getConnection( DB_MASTER );
 227                 } );
 228                 $factory->commitMasterChanges( __METHOD__ );
 229                 $this->assertEquals( 1, $called );
 230                 $this->assertEquals( 2, $countLBsFunc( $factory ) );
 231                 $factory->shutdown();
 232                 $factory->closeAll();
 233
 234                 $factory = $this->newLBFactoryMultiLBs();
 235                 $dbw = $factory->getMainLB()->getConnection( DB_MASTER );
 236                 // DBTransactionError should not be thrown
 237                 $ran = 0;
 238                 $dbw->onTransactionPreCommitOrIdle( function () use ( &$ran ) {
 239                         ++$ran;
 240                 } );
 241                 $factory->commitAll( __METHOD__ );
 242                 $this->assertEquals( 1, $ran );
 243
 244                 $factory->shutdown();
 245                 $factory->closeAll();
 246         }
 247
 248         private function newLBFactoryMultiLBs() {
 249                 global $wgDBserver, $wgDBname, $wgDBuser, $wgDBpassword, $wgDBtype, $wgSQLiteDataDir;
 250
 251                 return new LBFactoryMulti( [
 252                         'sectionsByDB' => [
 253                                 's1wiki' => 's1',
 254                         ],
 255                         'sectionLoads' => [
 256                                 's1' => [
 257                                         'test-db3' => 0,
 258                                         'test-db4' => 100,
 259                                 ],
 260                                 'DEFAULT' => [
 261                                         'test-db1' => 0,
 262                                         'test-db2' => 100,
 263                                 ]
 264                         ],
 265                         'serverTemplate' => [
 266                                 'dbname' => $wgDBname,
 267                                 'user' => $wgDBuser,
 268                                 'password' => $wgDBpassword,
 269                                 'type' => $wgDBtype,
 270                                 'dbDirectory' => $wgSQLiteDataDir,
 271                                 'flags' => DBO_DEFAULT
 272                         ],
 273                         'hostsByName' => [
 274                                 'test-db1' => $wgDBserver,
 275                                 'test-db2' => $wgDBserver,
 276                                 'test-db3' => $wgDBserver,
 277                                 'test-db4' => $wgDBserver
 278                         ],
 279                         'loadMonitorClass' => LoadMonitorNull::class
 280                 ] );
 281         }
 282
 283         /**
 284          * @covers \Wikimedia\Rdbms\ChronologyProtector
 285          */
 286         public function testChronologyProtector() {
 287                 $now = microtime( true );
 288
 289                 // (a) First HTTP request
 290                 $m1Pos = new MySQLMasterPos( 'db1034-bin.000976/843431247', $now );
 291                 $m2Pos = new MySQLMasterPos( 'db1064-bin.002400/794074907', $now );
 292
 293                 // Master DB 1
 294                 $mockDB1 = $this->getMockBuilder( IDatabase::class )
 295                         ->disableOriginalConstructor()
 296                         ->getMock();
 297                 $mockDB1->method( 'writesOrCallbacksPending' )->willReturn( true );
 298                 $mockDB1->method( 'lastDoneWrites' )->willReturn( $now );
 299                 $mockDB1->method( 'getMasterPos' )->willReturn( $m1Pos );
 300                 // Load balancer for master DB 1
 301                 $lb1 = $this->getMockBuilder( LoadBalancer::class )
 302                         ->disableOriginalConstructor()
 303                         ->getMock();
 304                 $lb1->method( 'getConnection' )->willReturn( $mockDB1 );
 305                 $lb1->method( 'getServerCount' )->willReturn( 2 );
 306                 $lb1->method( 'hasReplicaServers' )->willReturn( true );
 307                 $lb1->method( 'hasStreamingReplicaServers' )->willReturn( true );
 308                 $lb1->method( 'getAnyOpenConnection' )->willReturn( $mockDB1 );
 309                 $lb1->method( 'hasOrMadeRecentMasterChanges' )->will( $this->returnCallback(
 310                                 function () use ( $mockDB1 ) {
 311                                         $p = 0;
 312                                         $p |= call_user_func( [ $mockDB1, 'writesOrCallbacksPending' ] );
 313                                         $p |= call_user_func( [ $mockDB1, 'lastDoneWrites' ] );
 314
 315                                         return (bool)$p;
 316                                 }
 317                         ) );
 318                 $lb1->method( 'getMasterPos' )->willReturn( $m1Pos );
 319                 $lb1->method( 'getReplicaResumePos' )->willReturn( $m1Pos );
 320                 $lb1->method( 'getServerName' )->with( 0 )->willReturn( 'master1' );
 321                 // Master DB 2
 322                 $mockDB2 = $this->getMockBuilder( IDatabase::class )
 323                         ->disableOriginalConstructor()
 324                         ->getMock();
 325                 $mockDB2->method( 'writesOrCallbacksPending' )->willReturn( true );
 326                 $mockDB2->method( 'lastDoneWrites' )->willReturn( $now );
 327                 $mockDB2->method( 'getMasterPos' )->willReturn( $m2Pos );
 328                 // Load balancer for master DB 2
 329                 $lb2 = $this->getMockBuilder( LoadBalancer::class )
 330                         ->disableOriginalConstructor()
 331                         ->getMock();
 332                 $lb2->method( 'getConnection' )->willReturn( $mockDB2 );
 333                 $lb2->method( 'getServerCount' )->willReturn( 2 );
 334                 $lb2->method( 'hasReplicaServers' )->willReturn( true );
 335                 $lb2->method( 'hasStreamingReplicaServers' )->willReturn( true );
 336                 $lb2->method( 'getAnyOpenConnection' )->willReturn( $mockDB2 );
 337                 $lb2->method( 'hasOrMadeRecentMasterChanges' )->will( $this->returnCallback(
 338                         function () use ( $mockDB2 ) {
 339                                 $p = 0;
 340                                 $p |= call_user_func( [ $mockDB2, 'writesOrCallbacksPending' ] );
 341                                 $p |= call_user_func( [ $mockDB2, 'lastDoneWrites' ] );
 342
 343                                 return (bool)$p;
 344                         }
 345                 ) );
 346                 $lb2->method( 'getMasterPos' )->willReturn( $m2Pos );
 347                 $lb2->method( 'getReplicaResumePos' )->willReturn( $m2Pos );
 348                 $lb2->method( 'getServerName' )->with( 0 )->willReturn( 'master2' );
 349
 350                 $bag = new HashBagOStuff();
 351                 $cp = new ChronologyProtector(
 352                         $bag,
 353                         [
 354                                 'ip' => '127.0.0.1',
 355                                 'agent' => "Totally-Not-FireFox"
 356                         ],
 357                         null
 358                 );
 359
 360                 $mockDB1->expects( $this->exactly( 1 ) )->method( 'writesOrCallbacksPending' );
 361                 $mockDB1->expects( $this->exactly( 1 ) )->method( 'lastDoneWrites' );
 362                 $mockDB2->expects( $this->exactly( 1 ) )->method( 'writesOrCallbacksPending' );
 363                 $mockDB2->expects( $this->exactly( 1 ) )->method( 'lastDoneWrites' );
 364
 365                 // Nothing to wait for on first HTTP request start
 366                 $cp->applySessionReplicationPosition( $lb1 );
 367                 $cp->applySessionReplicationPosition( $lb2 );
 368                 // Record positions in stash on first HTTP request end
 369                 $cp->storeSessionReplicationPosition( $lb1 );
 370                 $cp->storeSessionReplicationPosition( $lb2 );
 371                 $cpIndex = null;
 372                 $cp->shutdown( null, 'sync', $cpIndex );
 373
 374                 $this->assertEquals( 1, $cpIndex, "CP write index set" );
 375
 376                 // (b) Second HTTP request
 377
 378                 // Load balancer for master DB 1
 379                 $lb1 = $this->getMockBuilder( LoadBalancer::class )
 380                         ->disableOriginalConstructor()
 381                         ->getMock();
 382                 $lb1->method( 'getServerCount' )->willReturn( 2 );
 383                 $lb1->method( 'hasReplicaServers' )->willReturn( true );
 384                 $lb1->method( 'hasStreamingReplicaServers' )->willReturn( true );
 385                 $lb1->method( 'getServerName' )->with( 0 )->willReturn( 'master1' );
 386                 $lb1->expects( $this->once() )
 387                         ->method( 'waitFor' )->with( $this->equalTo( $m1Pos ) );
 388                 // Load balancer for master DB 2
 389                 $lb2 = $this->getMockBuilder( LoadBalancer::class )
 390                         ->disableOriginalConstructor()
 391                         ->getMock();
 392                 $lb2->method( 'getServerCount' )->willReturn( 2 );
 393                 $lb2->method( 'hasReplicaServers' )->willReturn( true );
 394                 $lb2->method( 'hasStreamingReplicaServers' )->willReturn( true );
 395                 $lb2->method( 'getServerName' )->with( 0 )->willReturn( 'master2' );
 396                 $lb2->expects( $this->once() )
 397                         ->method( 'waitFor' )->with( $this->equalTo( $m2Pos ) );
 398
 399                 $cp = new ChronologyProtector(
 400                         $bag,
 401                         [
 402                                 'ip' => '127.0.0.1',
 403                                 'agent' => "Totally-Not-FireFox"
 404                         ],
 405                         $cpIndex
 406                 );
 407
 408                 // Wait for last positions to be reached on second HTTP request start
 409                 $cp->applySessionReplicationPosition( $lb1 );
 410                 $cp->applySessionReplicationPosition( $lb2 );
 411                 // Shutdown (nothing to record)
 412                 $cp->storeSessionReplicationPosition( $lb1 );
 413                 $cp->storeSessionReplicationPosition( $lb2 );
 414                 $cpIndex = null;
 415                 $cp->shutdown( null, 'sync', $cpIndex );
 416
 417                 $this->assertEquals( null, $cpIndex, "CP write index retained" );
 418
 419                 $this->assertEquals( '45e93a9c215c031d38b7c42d8e4700ca', $cp->getClientId() );
 420         }
 421
 422         private function newLBFactoryMulti( array $baseOverride = [], array $serverOverride = [] ) {
 423                 global $wgDBserver, $wgDBuser, $wgDBpassword, $wgDBname, $wgDBprefix, $wgDBtype;
 424                 global $wgSQLiteDataDir;
 425
 426                 return new LBFactoryMulti( $baseOverride + [
 427                         'sectionsByDB' => [],
 428                         'sectionLoads' => [
 429                                 'DEFAULT' => [
 430                                         'test-db1' => 1,
 431                                 ],
 432                         ],
 433                         'serverTemplate' => $serverOverride + [
 434                                 'dbname' => $wgDBname,
 435                                 'tablePrefix' => $wgDBprefix,
 436                                 'user' => $wgDBuser,
 437                                 'password' => $wgDBpassword,
 438                                 'type' => $wgDBtype,
 439                                 'dbDirectory' => $wgSQLiteDataDir,
 440                                 'flags' => DBO_DEFAULT
 441                         ],
 442                         'hostsByName' => [
 443                                 'test-db1' => $wgDBserver,
 444                         ],
 445                         'loadMonitorClass' => LoadMonitorNull::class,
 446                         'localDomain' => new DatabaseDomain( $wgDBname, null, $wgDBprefix ),
 447                         'agent' => 'MW-UNIT-TESTS'
 448                 ] );
 449         }
 450
 451         /**
 452          * @covers \Wikimedia\Rdbms\LoadBalancer::getConnection
 453          * @covers \Wikimedia\Rdbms\DatabaseMysqlBase::doSelectDomain
 454          * @covers \Wikimedia\Rdbms\DatabaseMysqlBase::selectDB
 455          */
 456         public function testNiceDomains() {
 457                 global $wgDBname;
 458
 459                 if ( wfGetDB( DB_MASTER )->databasesAreIndependent() ) {
 460                         self::markTestSkipped( "Skipping tests about selecting DBs: not applicable" );
 461                         return;
 462                 }
 463
 464                 $factory = $this->newLBFactoryMulti(
 465                         [],
 466                         []
 467                 );
 468                 $lb = $factory->getMainLB();
 469
 470                 $db = $lb->getConnectionRef( DB_MASTER );
 471                 $this->assertEquals(
 472                         wfWikiID(),
 473                         $db->getDomainID()
 474                 );
 475                 unset( $db );
 476
 477                 /** @var IMaintainableDatabase $db */
 478                 $db = $lb->getConnection( DB_MASTER, [], $lb::DOMAIN_ANY );
 479
 480                 $this->assertEquals(
 481                         '',
 482                         $db->getDomainId(),
 483                         'Null domain ID handle used'
 484                 );
 485                 $this->assertEquals(
 486                         '',
 487                         $db->getDBname(),
 488                         'Null domain ID handle used'
 489                 );
 490                 $this->assertEquals(
 491                         '',
 492                         $db->tablePrefix(),
 493                         'Main domain ID handle used; prefix is empty though'
 494                 );
 495                 $this->assertEquals(
 496                         $this->quoteTable( $db, 'page' ),
 497                         $db->tableName( 'page' ),
 498                         "Correct full table name"
 499                 );
 500                 $this->assertEquals(
 501                         $this->quoteTable( $db, $wgDBname ) . '.' . $this->quoteTable( $db, 'page' ),
 502                         $db->tableName( "$wgDBname.page" ),
 503                         "Correct full table name"
 504                 );
 505                 $this->assertEquals(
 506                         $this->quoteTable( $db, 'nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 507                         $db->tableName( 'nice_db.page' ),
 508                         "Correct full table name"
 509                 );
 510
 511                 $lb->reuseConnection( $db ); // don't care
 512
 513                 $db = $lb->getConnection( DB_MASTER ); // local domain connection
 514                 $factory->setLocalDomainPrefix( 'my_' );
 515
 516                 $this->assertEquals( $wgDBname, $db->getDBname() );
 517                 $this->assertEquals(
 518                         "$wgDBname-my_",
 519                         $db->getDomainID()
 520                 );
 521                 $this->assertEquals(
 522                         $this->quoteTable( $db, 'my_page' ),
 523                         $db->tableName( 'page' ),
 524                         "Correct full table name"
 525                 );
 526                 $this->assertEquals(
 527                         $this->quoteTable( $db, 'other_nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 528                         $db->tableName( 'other_nice_db.page' ),
 529                         "Correct full table name"
 530                 );
 531
 532                 $factory->closeAll();
 533                 $factory->destroy();
 534         }
 535
 536         /**
 537          * @covers \Wikimedia\Rdbms\LoadBalancer::getConnection
 538          * @covers \Wikimedia\Rdbms\DatabaseMysqlBase::doSelectDomain
 539          * @covers \Wikimedia\Rdbms\DatabaseMysqlBase::selectDB
 540          */
 541         public function testTrickyDomain() {
 542                 global $wgDBname;
 543
 544                 if ( wfGetDB( DB_MASTER )->databasesAreIndependent() ) {
 545                         self::markTestSkipped( "Skipping tests about selecting DBs: not applicable" );
 546                         return;
 547                 }
 548
 549                 $dbname = 'unittest-domain'; // explodes if DB is selected
 550                 $factory = $this->newLBFactoryMulti(
 551                         [ 'localDomain' => ( new DatabaseDomain( $dbname, null, '' ) )->getId() ],
 552                         [
 553                                 'dbname' => 'do_not_select_me' // explodes if DB is selected
 554                         ]
 555                 );
 556                 $lb = $factory->getMainLB();
 557                 /** @var IMaintainableDatabase $db */
 558                 $db = $lb->getConnection( DB_MASTER, [], $lb::DOMAIN_ANY );
 559
 560                 $this->assertEquals( '', $db->getDomainID(), "Null domain used" );
 561
 562                 $this->assertEquals(
 563                         $this->quoteTable( $db, 'page' ),
 564                         $db->tableName( 'page' ),
 565                         "Correct full table name"
 566                 );
 567
 568                 $this->assertEquals(
 569                         $this->quoteTable( $db, $dbname ) . '.' . $this->quoteTable( $db, 'page' ),
 570                         $db->tableName( "$dbname.page" ),
 571                         "Correct full table name"
 572                 );
 573
 574                 $this->assertEquals(
 575                         $this->quoteTable( $db, 'nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 576                         $db->tableName( 'nice_db.page' ),
 577                         "Correct full table name"
 578                 );
 579
 580                 $lb->reuseConnection( $db ); // don't care
 581
 582                 $factory->setLocalDomainPrefix( 'my_' );
 583                 $db = $lb->getConnection( DB_MASTER, [], "$wgDBname-my_" );
 584
 585                 $this->assertEquals(
 586                         $this->quoteTable( $db, 'my_page' ),
 587                         $db->tableName( 'page' ),
 588                         "Correct full table name"
 589                 );
 590                 $this->assertEquals(
 591                         $this->quoteTable( $db, 'other_nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 592                         $db->tableName( 'other_nice_db.page' ),
 593                         "Correct full table name"
 594                 );
 595                 $this->assertEquals(
 596                         $this->quoteTable( $db, 'garbage-db' ) . '.' . $this->quoteTable( $db, 'page' ),
 597                         $db->tableName( 'garbage-db.page' ),
 598                         "Correct full table name"
 599                 );
 600
 601                 $lb->reuseConnection( $db ); // don't care
 602
 603                 $factory->closeAll();
 604                 $factory->destroy();
 605         }
 606
 607         /**
 608          * @covers \Wikimedia\Rdbms\LoadBalancer::getConnection
 609          * @covers \Wikimedia\Rdbms\DatabaseMysqlBase::doSelectDomain
 610          * @covers \Wikimedia\Rdbms\DatabaseMysqlBase::selectDB
 611          */
 612         public function testInvalidSelectDB() {
 613                 if ( wfGetDB( DB_MASTER )->databasesAreIndependent() ) {
 614                         $this->markTestSkipped( "Not applicable per databasesAreIndependent()" );
 615                 }
 616
 617                 $dbname = 'unittest-domain'; // explodes if DB is selected
 618                 $factory = $this->newLBFactoryMulti(
 619                         [ 'localDomain' => ( new DatabaseDomain( $dbname, null, '' ) )->getId() ],
 620                         [
 621                                 'dbname' => 'do_not_select_me' // explodes if DB is selected
 622                         ]
 623                 );
 624                 $lb = $factory->getMainLB();
 625                 /** @var IDatabase $db */
 626                 $db = $lb->getConnection( DB_MASTER, [], $lb::DOMAIN_ANY );
 627
 628                 AtEase::suppressWarnings();
 629                 try {
 630                         $this->assertFalse( $db->selectDomain( 'garbagedb' ) );
 631                         $this->fail( "No error thrown." );
 632                 } catch ( \Wikimedia\Rdbms\DBQueryError $e ) {
 633                         $this->assertRegExp( '/[\'"]garbagedb[\'"]/', $e->getMessage() );
 634                 }
 635                 AtEase::restoreWarnings();
 636         }
 637
 638         /**
 639          * @covers \Wikimedia\Rdbms\DatabaseSqlite::selectDB
 640          * @covers \Wikimedia\Rdbms\DatabasePostgres::selectDB
 641          * @expectedException \Wikimedia\Rdbms\DBConnectionError
 642          */
 643         public function testInvalidSelectDBIndependent() {
 644                 $dbname = 'unittest-domain'; // explodes if DB is selected
 645                 $factory = $this->newLBFactoryMulti(
 646                         [ 'localDomain' => ( new DatabaseDomain( $dbname, null, '' ) )->getId() ],
 647                         [
 648                                 // Explodes with SQLite and Postgres during open/USE
 649                                 'dbname' => 'bad_dir/do_not_select_me'
 650                         ]
 651                 );
 652                 $lb = $factory->getMainLB();
 653
 654                 if ( !$factory->getMainLB()->getServerAttributes( 0 )[Database::ATTR_DB_IS_FILE] ) {
 655                         $this->markTestSkipped( "Not applicable per ATTR_DB_IS_FILE" );
 656                 }
 657
 658                 /** @var IDatabase $db */
 659                 $this->assertNotNull( $lb->getConnection( DB_MASTER, [], $lb::DOMAIN_ANY ) );
 660         }
 661
 662         /**
 663          * @covers \Wikimedia\Rdbms\DatabaseSqlite::selectDB
 664          * @covers \Wikimedia\Rdbms\DatabasePostgres::selectDB
 665          * @expectedException \Wikimedia\Rdbms\DBExpectedError
 666          */
 667         public function testInvalidSelectDBIndependent2() {
 668                 $dbname = 'unittest-domain'; // explodes if DB is selected
 669                 $factory = $this->newLBFactoryMulti(
 670                         [ 'localDomain' => ( new DatabaseDomain( $dbname, null, '' ) )->getId() ],
 671                         [
 672                                 // Explodes with SQLite and Postgres during open/USE
 673                                 'dbname' => 'bad_dir/do_not_select_me'
 674                         ]
 675                 );
 676                 $lb = $factory->getMainLB();
 677
 678                 if ( !$lb->getConnection( DB_MASTER )->databasesAreIndependent() ) {
 679                         $this->markTestSkipped( "Not applicable per databasesAreIndependent()" );
 680                 }
 681
 682                 $db = $lb->getConnection( DB_MASTER );
 683                 $db->selectDomain( 'garbage-db' );
 684         }
 685
 686         /**
 687          * @covers \Wikimedia\Rdbms\LoadBalancer::getConnection
 688          * @covers \Wikimedia\Rdbms\LoadBalancer::redefineLocalDomain
 689          * @covers \Wikimedia\Rdbms\DatabaseMysqlBase::selectDB
 690          */
 691         public function testRedefineLocalDomain() {
 692                 global $wgDBname;
 693
 694                 if ( wfGetDB( DB_MASTER )->databasesAreIndependent() ) {
 695                         self::markTestSkipped( "Skipping tests about selecting DBs: not applicable" );
 696                         return;
 697                 }
 698
 699                 $factory = $this->newLBFactoryMulti(
 700                         [],
 701                         []
 702                 );
 703                 $lb = $factory->getMainLB();
 704
 705                 $conn1 = $lb->getConnectionRef( DB_MASTER );
 706                 $this->assertEquals(
 707                         wfWikiID(),
 708                         $conn1->getDomainID()
 709                 );
 710                 unset( $conn1 );
 711
 712                 $factory->redefineLocalDomain( 'somedb-prefix_' );
 713                 $this->assertEquals( 'somedb-prefix_', $factory->getLocalDomainID() );
 714
 715                 $domain = new DatabaseDomain( $wgDBname, null, 'pref_' );
 716                 $factory->redefineLocalDomain( $domain );
 717
 718                 $n = 0;
 719                 $lb->forEachOpenConnection( function () use ( &$n ) {
 720                         ++$n;
 721                 } );
 722                 $this->assertEquals( 0, $n, "Connections closed" );
 723
 724                 $conn2 = $lb->getConnectionRef( DB_MASTER );
 725                 $this->assertEquals(
 726                         $domain->getId(),
 727                         $conn2->getDomainID()
 728                 );
 729                 unset( $conn2 );
 730
 731                 $factory->closeAll();
 732                 $factory->destroy();
 733         }
 734
 735         private function quoteTable( IDatabase $db, $table ) {
 736                 if ( $db->getType() === 'sqlite' ) {
 737                         return $table;
 738                 } else {
 739                         return $db->addIdentifierQuotes( $table );
 740                 }
 741         }
 742
 743         /**
 744          * @covers \Wikimedia\Rdbms\LBFactory::makeCookieValueFromCPIndex()
 745          * @covers \Wikimedia\Rdbms\LBFactory::getCPInfoFromCookieValue()
 746          */
 747         public function testCPPosIndexCookieValues() {
 748                 $time = 1526522031;
 749                 $agentId = md5( 'Ramsey\'s Loyal Presa Canario' );
 750
 751                 $this->assertEquals(
 752                         '3@542#c47dcfb0566e7d7bc110a6128a45c93a',
 753                         LBFactory::makeCookieValueFromCPIndex( 3, 542, $agentId )
 754                 );
 755
 756                 $lbFactory = $this->newLBFactoryMulti();
 757                 $lbFactory->setRequestInfo( [ 'IPAddress' => '10.64.24.52', 'UserAgent' => 'meow' ] );
 758                 $this->assertEquals(
 759                         '1@542#c47dcfb0566e7d7bc110a6128a45c93a',
 760                         LBFactory::makeCookieValueFromCPIndex( 1, 542, $agentId )
 761                 );
 762
 763                 $this->assertSame(
 764                         null,
 765                         LBFactory::getCPInfoFromCookieValue( "5#$agentId", $time - 10 )['index'],
 766                         'No time set'
 767                 );
 768                 $this->assertSame(
 769                         null,
 770                         LBFactory::getCPInfoFromCookieValue( "5@$time", $time - 10 )['index'],
 771                         'No agent set'
 772                 );
 773                 $this->assertSame(
 774                         null,
 775                         LBFactory::getCPInfoFromCookieValue( "0@$time#$agentId", $time - 10 )['index'],
 776                         'Bad index'
 777                 );
 778
 779                 $this->assertSame(
 780                         2,
 781                         LBFactory::getCPInfoFromCookieValue( "2@$time#$agentId", $time - 10 )['index'],
 782                         'Fresh'
 783                 );
 784                 $this->assertSame(
 785                         2,
 786                         LBFactory::getCPInfoFromCookieValue( "2@$time#$agentId", $time + 9 - 10 )['index'],
 787                         'Almost stale'
 788                 );
 789                 $this->assertSame(
 790                         null,
 791                         LBFactory::getCPInfoFromCookieValue( "0@$time#$agentId", $time + 9 - 10 )['index'],
 792                         'Almost stale; bad index'
 793                 );
 794                 $this->assertSame(
 795                         null,
 796                         LBFactory::getCPInfoFromCookieValue( "2@$time#$agentId", $time + 11 - 10 )['index'],
 797                         'Stale'
 798                 );
 799
 800                 $this->assertSame(
 801                         $agentId,
 802                         LBFactory::getCPInfoFromCookieValue( "5@$time#$agentId", $time - 10 )['clientId'],
 803                         'Live (client ID)'
 804                 );
 805                 $this->assertSame(
 806                         null,
 807                         LBFactory::getCPInfoFromCookieValue( "5@$time#$agentId", $time + 11 - 10 )['clientId'],
 808                         'Stale (client ID)'
 809                 );
 810         }
 811 }