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