tests/phpunit/includes/Storage/RevisionStoreTest.php

   1 <?php
   2
   3 namespace MediaWiki\Tests\Storage;
   4
   5 use HashBagOStuff;
   6 use Language;
   7 use MediaWiki\Storage\RevisionAccessException;
   8 use MediaWiki\Storage\RevisionStore;
   9 use MediaWiki\Storage\SqlBlobStore;
  10 use MediaWikiTestCase;
  11 use Title;
  12 use WANObjectCache;
  13 use Wikimedia\Rdbms\Database;
  14 use Wikimedia\Rdbms\LoadBalancer;
  15
  16 class RevisionStoreTest extends MediaWikiTestCase {
  17
  18         /**
  19          * @param LoadBalancer $loadBalancer
  20          * @param SqlBlobStore $blobStore
  21          * @param WANObjectCache $WANObjectCache
  22          *
  23          * @return RevisionStore
  24          */
  25         private function getRevisionStore(
  26                 $loadBalancer = null,
  27                 $blobStore = null,
  28                 $WANObjectCache = null
  29         ) {
  30                 return new RevisionStore(
  31                         $loadBalancer ? $loadBalancer : $this->getMockLoadBalancer(),
  32                         $blobStore ? $blobStore : $this->getMockSqlBlobStore(),
  33                         $WANObjectCache ? $WANObjectCache : $this->getHashWANObjectCache()
  34                 );
  35         }
  36
  37         /**
  38          * @return \PHPUnit_Framework_MockObject_MockObject|LoadBalancer
  39          */
  40         private function getMockLoadBalancer() {
  41                 return $this->getMockBuilder( LoadBalancer::class )
  42                         ->disableOriginalConstructor()->getMock();
  43         }
  44
  45         /**
  46          * @return \PHPUnit_Framework_MockObject_MockObject|Database
  47          */
  48         private function getMockDatabase() {
  49                 return $this->getMockBuilder( Database::class )
  50                         ->disableOriginalConstructor()->getMock();
  51         }
  52
  53         /**
  54          * @return \PHPUnit_Framework_MockObject_MockObject|SqlBlobStore
  55          */
  56         private function getMockSqlBlobStore() {
  57                 return $this->getMockBuilder( SqlBlobStore::class )
  58                         ->disableOriginalConstructor()->getMock();
  59         }
  60
  61         private function getHashWANObjectCache() {
  62                 return new WANObjectCache( [ 'cache' => new \HashBagOStuff() ] );
  63         }
  64
  65         /**
  66          * @covers \MediaWiki\Storage\RevisionStore::getContentHandlerUseDB
  67          * @covers \MediaWiki\Storage\RevisionStore::setContentHandlerUseDB
  68          */
  69         public function testGetSetContentHandlerDb() {
  70                 $store = $this->getRevisionStore();
  71                 $this->assertTrue( $store->getContentHandlerUseDB() );
  72                 $store->setContentHandlerUseDB( false );
  73                 $this->assertFalse( $store->getContentHandlerUseDB() );
  74                 $store->setContentHandlerUseDB( true );
  75                 $this->assertTrue( $store->getContentHandlerUseDB() );
  76         }
  77
  78         private function getDefaultQueryFields() {
  79                 return [
  80                         'rev_id',
  81                         'rev_page',
  82                         'rev_text_id',
  83                         'rev_timestamp',
  84                         'rev_user_text',
  85                         'rev_user',
  86                         'rev_minor_edit',
  87                         'rev_deleted',
  88                         'rev_len',
  89                         'rev_parent_id',
  90                         'rev_sha1',
  91                 ];
  92         }
  93
  94         private function getCommentQueryFields() {
  95                 return [
  96                         'rev_comment_text' => 'rev_comment',
  97                         'rev_comment_data' => 'NULL',
  98                         'rev_comment_cid' => 'NULL',
  99                 ];
 100         }
 101
 102         private function getContentHandlerQueryFields() {
 103                 return [
 104                         'rev_content_format',
 105                         'rev_content_model',
 106                 ];
 107         }
 108
 109         public function provideGetQueryInfo() {
 110                 yield [
 111                         true,
 112                         [],
 113                         [
 114                                 'tables' => [ 'revision' ],
 115                                 'fields' => array_merge(
 116                                         $this->getDefaultQueryFields(),
 117                                         $this->getCommentQueryFields(),
 118                                         $this->getContentHandlerQueryFields()
 119                                 ),
 120                                 'joins' => [],
 121                         ]
 122                 ];
 123                 yield [
 124                         false,
 125                         [],
 126                         [
 127                                 'tables' => [ 'revision' ],
 128                                 'fields' => array_merge(
 129                                         $this->getDefaultQueryFields(),
 130                                         $this->getCommentQueryFields()
 131                                 ),
 132                                 'joins' => [],
 133                         ]
 134                 ];
 135                 yield [
 136                         false,
 137                         [ 'page' ],
 138                         [
 139                                 'tables' => [ 'revision', 'page' ],
 140                                 'fields' => array_merge(
 141                                         $this->getDefaultQueryFields(),
 142                                         $this->getCommentQueryFields(),
 143                                         [
 144                                                 'page_namespace',
 145                                                 'page_title',
 146                                                 'page_id',
 147                                                 'page_latest',
 148                                                 'page_is_redirect',
 149                                                 'page_len',
 150                                         ]
 151                                 ),
 152                                 'joins' => [
 153                                         'page' => [ 'INNER JOIN', [ 'page_id = rev_page' ] ],
 154                                 ],
 155                         ]
 156                 ];
 157                 yield [
 158                         false,
 159                         [ 'user' ],
 160                         [
 161                                 'tables' => [ 'revision', 'user' ],
 162                                 'fields' => array_merge(
 163                                         $this->getDefaultQueryFields(),
 164                                         $this->getCommentQueryFields(),
 165                                         [
 166                                                 'user_name',
 167                                         ]
 168                                 ),
 169                                 'joins' => [
 170                                         'user' => [ 'LEFT JOIN', [ 'rev_user != 0', 'user_id = rev_user' ] ],
 171                                 ],
 172                         ]
 173                 ];
 174                 yield [
 175                         false,
 176                         [ 'text' ],
 177                         [
 178                                 'tables' => [ 'revision', 'text' ],
 179                                 'fields' => array_merge(
 180                                         $this->getDefaultQueryFields(),
 181                                         $this->getCommentQueryFields(),
 182                                         [
 183                                                 'old_text',
 184                                                 'old_flags',
 185                                         ]
 186                                 ),
 187                                 'joins' => [
 188                                         'text' => [ 'INNER JOIN', [ 'rev_text_id=old_id' ] ],
 189                                 ],
 190                         ]
 191                 ];
 192                 yield [
 193                         true,
 194                         [ 'page', 'user', 'text' ],
 195                         [
 196                                 'tables' => [ 'revision', 'page', 'user', 'text' ],
 197                                 'fields' => array_merge(
 198                                         $this->getDefaultQueryFields(),
 199                                         $this->getCommentQueryFields(),
 200                                         $this->getContentHandlerQueryFields(),
 201                                         [
 202                                                 'page_namespace',
 203                                                 'page_title',
 204                                                 'page_id',
 205                                                 'page_latest',
 206                                                 'page_is_redirect',
 207                                                 'page_len',
 208                                                 'user_name',
 209                                                 'old_text',
 210                                                 'old_flags',
 211                                         ]
 212                                 ),
 213                                 'joins' => [
 214                                         'page' => [ 'INNER JOIN', [ 'page_id = rev_page' ] ],
 215                                         'user' => [ 'LEFT JOIN', [ 'rev_user != 0', 'user_id = rev_user' ] ],
 216                                         'text' => [ 'INNER JOIN', [ 'rev_text_id=old_id' ] ],
 217                                 ],
 218                         ]
 219                 ];
 220         }
 221
 222         /**
 223          * @dataProvider provideGetQueryInfo
 224          * @covers \MediaWiki\Storage\RevisionStore::getQueryInfo
 225          */
 226         public function testGetQueryInfo( $contentHandlerUseDb, $options, $expected ) {
 227                 $store = $this->getRevisionStore();
 228                 $store->setContentHandlerUseDB( $contentHandlerUseDb );
 229                 $this->setMwGlobals( 'wgCommentTableSchemaMigrationStage', MIGRATION_OLD );
 230                 $this->assertEquals( $expected, $store->getQueryInfo( $options ) );
 231         }
 232
 233         private function getDefaultArchiveFields() {
 234                 return [
 235                         'ar_id',
 236                         'ar_page_id',
 237                         'ar_namespace',
 238                         'ar_title',
 239                         'ar_rev_id',
 240                         'ar_text',
 241                         'ar_text_id',
 242                         'ar_timestamp',
 243                         'ar_user_text',
 244                         'ar_user',
 245                         'ar_minor_edit',
 246                         'ar_deleted',
 247                         'ar_len',
 248                         'ar_parent_id',
 249                         'ar_sha1',
 250                 ];
 251         }
 252
 253         /**
 254          * @covers \MediaWiki\Storage\RevisionStore::getArchiveQueryInfo
 255          */
 256         public function testGetArchiveQueryInfo_contentHandlerDb() {
 257                 $store = $this->getRevisionStore();
 258                 $store->setContentHandlerUseDB( true );
 259                 $this->setMwGlobals( 'wgCommentTableSchemaMigrationStage', MIGRATION_OLD );
 260                 $this->assertEquals(
 261                         [
 262                                 'tables' => [
 263                                         'archive'
 264                                 ],
 265                                 'fields' => array_merge(
 266                                         $this->getDefaultArchiveFields(),
 267                                         [
 268                                                 'ar_comment_text' => 'ar_comment',
 269                                                 'ar_comment_data' => 'NULL',
 270                                                 'ar_comment_cid' => 'NULL',
 271                                                 'ar_content_format',
 272                                                 'ar_content_model',
 273                                         ]
 274                                 ),
 275                                 'joins' => [],
 276                         ],
 277                         $store->getArchiveQueryInfo()
 278                 );
 279         }
 280
 281         /**
 282          * @covers \MediaWiki\Storage\RevisionStore::getArchiveQueryInfo
 283          */
 284         public function testGetArchiveQueryInfo_noContentHandlerDb() {
 285                 $store = $this->getRevisionStore();
 286                 $store->setContentHandlerUseDB( false );
 287                 $this->setMwGlobals( 'wgCommentTableSchemaMigrationStage', MIGRATION_OLD );
 288                 $this->assertEquals(
 289                         [
 290                                 'tables' => [
 291                                         'archive'
 292                                 ],
 293                                 'fields' => array_merge(
 294                                         $this->getDefaultArchiveFields(),
 295                                         [
 296                                                 'ar_comment_text' => 'ar_comment',
 297                                                 'ar_comment_data' => 'NULL',
 298                                                 'ar_comment_cid' => 'NULL',
 299                                         ]
 300                                 ),
 301                                 'joins' => [],
 302                         ],
 303                         $store->getArchiveQueryInfo()
 304                 );
 305         }
 306
 307         public function testGetTitle_successFromPageId() {
 308                 $mockLoadBalancer = $this->getMockLoadBalancer();
 309                 // Title calls wfGetDB() so we have to set the main service
 310                 $this->setService( 'DBLoadBalancer', $mockLoadBalancer );
 311
 312                 $db = $this->getMockDatabase();
 313                 // Title calls wfGetDB() which uses a regular Connection
 314                 $mockLoadBalancer->expects( $this->atLeastOnce() )
 315                         ->method( 'getConnection' )
 316                         ->willReturn( $db );
 317
 318                 // First call to Title::newFromID, faking no result (db lag?)
 319                 $db->expects( $this->at( 0 ) )
 320                         ->method( 'selectRow' )
 321                         ->with(
 322                                 'page',
 323                                 $this->anything(),
 324                                 [ 'page_id' => 1 ]
 325                         )
 326                         ->willReturn( (object)[
 327                                 'page_namespace' => '1',
 328                                 'page_title' => 'Food',
 329                         ] );
 330
 331                 $store = $this->getRevisionStore( $mockLoadBalancer );
 332                 $title = $store->getTitle( 1, 2, RevisionStore::READ_NORMAL );
 333
 334                 $this->assertSame( 1, $title->getNamespace() );
 335                 $this->assertSame( 'Food', $title->getDBkey() );
 336         }
 337
 338         public function testGetTitle_successFromRevId() {
 339                 $mockLoadBalancer = $this->getMockLoadBalancer();
 340                 // Title calls wfGetDB() so we have to set the main service
 341                 $this->setService( 'DBLoadBalancer', $mockLoadBalancer );
 342
 343                 $db = $this->getMockDatabase();
 344                 // Title calls wfGetDB() which uses a regular Connection
 345                 $mockLoadBalancer->expects( $this->atLeastOnce() )
 346                         ->method( 'getConnection' )
 347                         ->willReturn( $db );
 348                 // RevisionStore getTitle uses a ConnectionRef
 349                 $mockLoadBalancer->expects( $this->atLeastOnce() )
 350                         ->method( 'getConnectionRef' )
 351                         ->willReturn( $db );
 352
 353                 // First call to Title::newFromID, faking no result (db lag?)
 354                 $db->expects( $this->at( 0 ) )
 355                         ->method( 'selectRow' )
 356                         ->with(
 357                                 'page',
 358                                 $this->anything(),
 359                                 [ 'page_id' => 1 ]
 360                         )
 361                         ->willReturn( false );
 362
 363                 // First select using rev_id, faking no result (db lag?)
 364                 $db->expects( $this->at( 1 ) )
 365                         ->method( 'selectRow' )
 366                         ->with(
 367                                 [ 'revision', 'page' ],
 368                                 $this->anything(),
 369                                 [ 'rev_id' => 2 ]
 370                         )
 371                         ->willReturn( (object)[
 372                                 'page_namespace' => '1',
 373                                 'page_title' => 'Food2',
 374                         ] );
 375
 376                 $store = $this->getRevisionStore( $mockLoadBalancer );
 377                 $title = $store->getTitle( 1, 2, RevisionStore::READ_NORMAL );
 378
 379                 $this->assertSame( 1, $title->getNamespace() );
 380                 $this->assertSame( 'Food2', $title->getDBkey() );
 381         }
 382
 383         /**
 384          * @covers \MediaWiki\Storage\RevisionStore::getTitle
 385          */
 386         public function testGetTitle_throwsExceptionAfterFallbacks() {
 387                 $mockLoadBalancer = $this->getMockLoadBalancer();
 388                 // Title calls wfGetDB() so we have to set the main service
 389                 $this->setService( 'DBLoadBalancer', $mockLoadBalancer );
 390
 391                 $db = $this->getMockDatabase();
 392                 // Title calls wfGetDB() which uses a regular Connection
 393                 $mockLoadBalancer->expects( $this->atLeastOnce() )
 394                         ->method( 'getConnection' )
 395                         ->willReturn( $db );
 396                 // RevisionStore getTitle uses a ConnectionRef
 397                 $mockLoadBalancer->expects( $this->atLeastOnce() )
 398                         ->method( 'getConnectionRef' )
 399                         ->willReturn( $db );
 400
 401                 // First call to Title::newFromID, faking no result (db lag?)
 402                 $db->expects( $this->at( 0 ) )
 403                         ->method( 'selectRow' )
 404                         ->with(
 405                                 'page',
 406                                 $this->anything(),
 407                                 [ 'page_id' => 1 ]
 408                         )
 409                         ->willReturn( false );
 410
 411                 // First select using rev_id, faking no result (db lag?)
 412                 $db->expects( $this->at( 1 ) )
 413                         ->method( 'selectRow' )
 414                         ->with(
 415                                 [ 'revision', 'page' ],
 416                                 $this->anything(),
 417                                 [ 'rev_id' => 2 ]
 418                         )
 419                         ->willReturn( false );
 420
 421                 $store = $this->getRevisionStore( $mockLoadBalancer );
 422
 423                 $this->setExpectedException( RevisionAccessException::class );
 424                 $store->getTitle( 1, 2, RevisionStore::READ_NORMAL );
 425         }
 426
 427         public function provideNewRevisionFromRow_legacyEncoding_applied() {
 428                 yield 'windows-1252, old_flags is empty' => [
 429                         'windows-1252',
 430                         'en',
 431                         [
 432                                 'old_flags' => '',
 433                                 'old_text' => "S\xF6me Content",
 434                         ],
 435                         'Söme Content'
 436                 ];
 437
 438                 yield 'windows-1252, old_flags is null' => [
 439                         'windows-1252',
 440                         'en',
 441                         [
 442                                 'old_flags' => null,
 443                                 'old_text' => "S\xF6me Content",
 444                         ],
 445                         'Söme Content'
 446                 ];
 447         }
 448
 449         /**
 450          * @dataProvider provideNewRevisionFromRow_legacyEncoding_applied
 451          *
 452          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow
 453          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow_1_29
 454          */
 455         public function testNewRevisionFromRow_legacyEncoding_applied( $encoding, $locale, $row, $text ) {
 456                 $cache = new WANObjectCache( [ 'cache' => new HashBagOStuff() ] );
 457
 458                 $blobStore = new SqlBlobStore( wfGetLB(), $cache );
 459                 $blobStore->setLegacyEncoding( $encoding, Language::factory( $locale ) );
 460
 461                 $store = new RevisionStore( wfGetLB(), $blobStore, $cache );
 462
 463                 $record = $store->newRevisionFromRow(
 464                         $this->makeRow( $row ),
 465                         0,
 466                         Title::newFromText( __METHOD__ . '-UTPage' )
 467                 );
 468
 469                 $this->assertSame( $text, $record->getContent( 'main' )->serialize() );
 470         }
 471
 472         /**
 473          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow
 474          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow_1_29
 475          */
 476         public function testNewRevisionFromRow_legacyEncoding_ignored() {
 477                 $row = [
 478                         'old_flags' => 'utf-8',
 479                         'old_text' => 'Söme Content',
 480                 ];
 481
 482                 $cache = new WANObjectCache( [ 'cache' => new HashBagOStuff() ] );
 483
 484                 $blobStore = new SqlBlobStore( wfGetLB(), $cache );
 485                 $blobStore->setLegacyEncoding( 'windows-1252', Language::factory( 'en' ) );
 486
 487                 $store = new RevisionStore( wfGetLB(), $blobStore, $cache );
 488
 489                 $record = $store->newRevisionFromRow(
 490                         $this->makeRow( $row ),
 491                         0,
 492                         Title::newFromText( __METHOD__ . '-UTPage' )
 493                 );
 494                 $this->assertSame( 'Söme Content', $record->getContent( 'main' )->serialize() );
 495         }
 496
 497         private function makeRow( array $array ) {
 498                 $row = $array + [
 499                                 'rev_id' => 7,
 500                                 'rev_page' => 5,
 501                                 'rev_text_id' => 11,
 502                                 'rev_timestamp' => '20110101000000',
 503                                 'rev_user_text' => 'Tester',
 504                                 'rev_user' => 17,
 505                                 'rev_minor_edit' => 0,
 506                                 'rev_deleted' => 0,
 507                                 'rev_len' => 100,
 508                                 'rev_parent_id' => 0,
 509                                 'rev_sha1' => 'deadbeef',
 510                                 'rev_comment_text' => 'Testing',
 511                                 'rev_comment_data' => '{}',
 512                                 'rev_comment_cid' => 111,
 513                                 'rev_content_format' => CONTENT_FORMAT_TEXT,
 514                                 'rev_content_model' => CONTENT_MODEL_TEXT,
 515                                 'page_namespace' => 0,
 516                                 'page_title' => 'TEST',
 517                                 'page_id' => 5,
 518                                 'page_latest' => 7,
 519                                 'page_is_redirect' => 0,
 520                                 'page_len' => 100,
 521                                 'user_name' => 'Tester',
 522                                 'old_is' => 13,
 523                                 'old_text' => 'Hello World',
 524                                 'old_flags' => 'utf-8',
 525                         ];
 526
 527                 return (object)$row;
 528         }
 529
 530 }