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                 $this->setMwGlobals( 'wgCommentTableSchemaMigrationStage', MIGRATION_OLD );
 228                 $this->overrideMwServices();
 229                 $store = $this->getRevisionStore();
 230                 $store->setContentHandlerUseDB( $contentHandlerUseDb );
 231                 $this->assertEquals( $expected, $store->getQueryInfo( $options ) );
 232         }
 233
 234         private function getDefaultArchiveFields() {
 235                 return [
 236                         'ar_id',
 237                         'ar_page_id',
 238                         'ar_namespace',
 239                         'ar_title',
 240                         'ar_rev_id',
 241                         'ar_text',
 242                         'ar_text_id',
 243                         'ar_timestamp',
 244                         'ar_user_text',
 245                         'ar_user',
 246                         'ar_minor_edit',
 247                         'ar_deleted',
 248                         'ar_len',
 249                         'ar_parent_id',
 250                         'ar_sha1',
 251                 ];
 252         }
 253
 254         /**
 255          * @covers \MediaWiki\Storage\RevisionStore::getArchiveQueryInfo
 256          */
 257         public function testGetArchiveQueryInfo_contentHandlerDb() {
 258                 $this->setMwGlobals( 'wgCommentTableSchemaMigrationStage', MIGRATION_OLD );
 259                 $this->overrideMwServices();
 260                 $store = $this->getRevisionStore();
 261                 $store->setContentHandlerUseDB( true );
 262                 $this->assertEquals(
 263                         [
 264                                 'tables' => [
 265                                         'archive'
 266                                 ],
 267                                 'fields' => array_merge(
 268                                         $this->getDefaultArchiveFields(),
 269                                         [
 270                                                 'ar_comment_text' => 'ar_comment',
 271                                                 'ar_comment_data' => 'NULL',
 272                                                 'ar_comment_cid' => 'NULL',
 273                                                 'ar_content_format',
 274                                                 'ar_content_model',
 275                                         ]
 276                                 ),
 277                                 'joins' => [],
 278                         ],
 279                         $store->getArchiveQueryInfo()
 280                 );
 281         }
 282
 283         /**
 284          * @covers \MediaWiki\Storage\RevisionStore::getArchiveQueryInfo
 285          */
 286         public function testGetArchiveQueryInfo_noContentHandlerDb() {
 287                 $this->setMwGlobals( 'wgCommentTableSchemaMigrationStage', MIGRATION_OLD );
 288                 $this->overrideMwServices();
 289                 $store = $this->getRevisionStore();
 290                 $store->setContentHandlerUseDB( false );
 291                 $this->assertEquals(
 292                         [
 293                                 'tables' => [
 294                                         'archive'
 295                                 ],
 296                                 'fields' => array_merge(
 297                                         $this->getDefaultArchiveFields(),
 298                                         [
 299                                                 'ar_comment_text' => 'ar_comment',
 300                                                 'ar_comment_data' => 'NULL',
 301                                                 'ar_comment_cid' => 'NULL',
 302                                         ]
 303                                 ),
 304                                 'joins' => [],
 305                         ],
 306                         $store->getArchiveQueryInfo()
 307                 );
 308         }
 309
 310         public function testGetTitle_successFromPageId() {
 311                 $mockLoadBalancer = $this->getMockLoadBalancer();
 312                 // Title calls wfGetDB() so we have to set the main service
 313                 $this->setService( 'DBLoadBalancer', $mockLoadBalancer );
 314
 315                 $db = $this->getMockDatabase();
 316                 // Title calls wfGetDB() which uses a regular Connection
 317                 $mockLoadBalancer->expects( $this->atLeastOnce() )
 318                         ->method( 'getConnection' )
 319                         ->willReturn( $db );
 320
 321                 // First call to Title::newFromID, faking no result (db lag?)
 322                 $db->expects( $this->at( 0 ) )
 323                         ->method( 'selectRow' )
 324                         ->with(
 325                                 'page',
 326                                 $this->anything(),
 327                                 [ 'page_id' => 1 ]
 328                         )
 329                         ->willReturn( (object)[
 330                                 'page_namespace' => '1',
 331                                 'page_title' => 'Food',
 332                         ] );
 333
 334                 $store = $this->getRevisionStore( $mockLoadBalancer );
 335                 $title = $store->getTitle( 1, 2, RevisionStore::READ_NORMAL );
 336
 337                 $this->assertSame( 1, $title->getNamespace() );
 338                 $this->assertSame( 'Food', $title->getDBkey() );
 339         }
 340
 341         public function testGetTitle_successFromRevId() {
 342                 $mockLoadBalancer = $this->getMockLoadBalancer();
 343                 // Title calls wfGetDB() so we have to set the main service
 344                 $this->setService( 'DBLoadBalancer', $mockLoadBalancer );
 345
 346                 $db = $this->getMockDatabase();
 347                 // Title calls wfGetDB() which uses a regular Connection
 348                 $mockLoadBalancer->expects( $this->atLeastOnce() )
 349                         ->method( 'getConnection' )
 350                         ->willReturn( $db );
 351                 // RevisionStore getTitle uses a ConnectionRef
 352                 $mockLoadBalancer->expects( $this->atLeastOnce() )
 353                         ->method( 'getConnectionRef' )
 354                         ->willReturn( $db );
 355
 356                 // First call to Title::newFromID, faking no result (db lag?)
 357                 $db->expects( $this->at( 0 ) )
 358                         ->method( 'selectRow' )
 359                         ->with(
 360                                 'page',
 361                                 $this->anything(),
 362                                 [ 'page_id' => 1 ]
 363                         )
 364                         ->willReturn( false );
 365
 366                 // First select using rev_id, faking no result (db lag?)
 367                 $db->expects( $this->at( 1 ) )
 368                         ->method( 'selectRow' )
 369                         ->with(
 370                                 [ 'revision', 'page' ],
 371                                 $this->anything(),
 372                                 [ 'rev_id' => 2 ]
 373                         )
 374                         ->willReturn( (object)[
 375                                 'page_namespace' => '1',
 376                                 'page_title' => 'Food2',
 377                         ] );
 378
 379                 $store = $this->getRevisionStore( $mockLoadBalancer );
 380                 $title = $store->getTitle( 1, 2, RevisionStore::READ_NORMAL );
 381
 382                 $this->assertSame( 1, $title->getNamespace() );
 383                 $this->assertSame( 'Food2', $title->getDBkey() );
 384         }
 385
 386         /**
 387          * @covers \MediaWiki\Storage\RevisionStore::getTitle
 388          */
 389         public function testGetTitle_throwsExceptionAfterFallbacks() {
 390                 $mockLoadBalancer = $this->getMockLoadBalancer();
 391                 // Title calls wfGetDB() so we have to set the main service
 392                 $this->setService( 'DBLoadBalancer', $mockLoadBalancer );
 393
 394                 $db = $this->getMockDatabase();
 395                 // Title calls wfGetDB() which uses a regular Connection
 396                 $mockLoadBalancer->expects( $this->atLeastOnce() )
 397                         ->method( 'getConnection' )
 398                         ->willReturn( $db );
 399                 // RevisionStore getTitle uses a ConnectionRef
 400                 $mockLoadBalancer->expects( $this->atLeastOnce() )
 401                         ->method( 'getConnectionRef' )
 402                         ->willReturn( $db );
 403
 404                 // First call to Title::newFromID, faking no result (db lag?)
 405                 $db->expects( $this->at( 0 ) )
 406                         ->method( 'selectRow' )
 407                         ->with(
 408                                 'page',
 409                                 $this->anything(),
 410                                 [ 'page_id' => 1 ]
 411                         )
 412                         ->willReturn( false );
 413
 414                 // First select using rev_id, faking no result (db lag?)
 415                 $db->expects( $this->at( 1 ) )
 416                         ->method( 'selectRow' )
 417                         ->with(
 418                                 [ 'revision', 'page' ],
 419                                 $this->anything(),
 420                                 [ 'rev_id' => 2 ]
 421                         )
 422                         ->willReturn( false );
 423
 424                 $store = $this->getRevisionStore( $mockLoadBalancer );
 425
 426                 $this->setExpectedException( RevisionAccessException::class );
 427                 $store->getTitle( 1, 2, RevisionStore::READ_NORMAL );
 428         }
 429
 430         public function provideNewRevisionFromRow_legacyEncoding_applied() {
 431                 yield 'windows-1252, old_flags is empty' => [
 432                         'windows-1252',
 433                         'en',
 434                         [
 435                                 'old_flags' => '',
 436                                 'old_text' => "S\xF6me Content",
 437                         ],
 438                         'Söme Content'
 439                 ];
 440
 441                 yield 'windows-1252, old_flags is null' => [
 442                         'windows-1252',
 443                         'en',
 444                         [
 445                                 'old_flags' => null,
 446                                 'old_text' => "S\xF6me Content",
 447                         ],
 448                         'Söme Content'
 449                 ];
 450         }
 451
 452         /**
 453          * @dataProvider provideNewRevisionFromRow_legacyEncoding_applied
 454          *
 455          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow
 456          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow_1_29
 457          */
 458         public function testNewRevisionFromRow_legacyEncoding_applied( $encoding, $locale, $row, $text ) {
 459                 $cache = new WANObjectCache( [ 'cache' => new HashBagOStuff() ] );
 460
 461                 $blobStore = new SqlBlobStore( wfGetLB(), $cache );
 462                 $blobStore->setLegacyEncoding( $encoding, Language::factory( $locale ) );
 463
 464                 $store = new RevisionStore( wfGetLB(), $blobStore, $cache );
 465
 466                 $record = $store->newRevisionFromRow(
 467                         $this->makeRow( $row ),
 468                         0,
 469                         Title::newFromText( __METHOD__ . '-UTPage' )
 470                 );
 471
 472                 $this->assertSame( $text, $record->getContent( 'main' )->serialize() );
 473         }
 474
 475         /**
 476          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow
 477          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow_1_29
 478          */
 479         public function testNewRevisionFromRow_legacyEncoding_ignored() {
 480                 $row = [
 481                         'old_flags' => 'utf-8',
 482                         'old_text' => 'Söme Content',
 483                 ];
 484
 485                 $cache = new WANObjectCache( [ 'cache' => new HashBagOStuff() ] );
 486
 487                 $blobStore = new SqlBlobStore( wfGetLB(), $cache );
 488                 $blobStore->setLegacyEncoding( 'windows-1252', Language::factory( 'en' ) );
 489
 490                 $store = new RevisionStore( wfGetLB(), $blobStore, $cache );
 491
 492                 $record = $store->newRevisionFromRow(
 493                         $this->makeRow( $row ),
 494                         0,
 495                         Title::newFromText( __METHOD__ . '-UTPage' )
 496                 );
 497                 $this->assertSame( 'Söme Content', $record->getContent( 'main' )->serialize() );
 498         }
 499
 500         private function makeRow( array $array ) {
 501                 $row = $array + [
 502                                 'rev_id' => 7,
 503                                 'rev_page' => 5,
 504                                 'rev_text_id' => 11,
 505                                 'rev_timestamp' => '20110101000000',
 506                                 'rev_user_text' => 'Tester',
 507                                 'rev_user' => 17,
 508                                 'rev_minor_edit' => 0,
 509                                 'rev_deleted' => 0,
 510                                 'rev_len' => 100,
 511                                 'rev_parent_id' => 0,
 512                                 'rev_sha1' => 'deadbeef',
 513                                 'rev_comment_text' => 'Testing',
 514                                 'rev_comment_data' => '{}',
 515                                 'rev_comment_cid' => 111,
 516                                 'rev_content_format' => CONTENT_FORMAT_TEXT,
 517                                 'rev_content_model' => CONTENT_MODEL_TEXT,
 518                                 'page_namespace' => 0,
 519                                 'page_title' => 'TEST',
 520                                 'page_id' => 5,
 521                                 'page_latest' => 7,
 522                                 'page_is_redirect' => 0,
 523                                 'page_len' => 100,
 524                                 'user_name' => 'Tester',
 525                                 'old_is' => 13,
 526                                 'old_text' => 'Hello World',
 527                                 'old_flags' => 'utf-8',
 528                         ];
 529
 530                 return (object)$row;
 531         }
 532
 533 }