tests/phpunit/includes/Storage/RevisionStoreDbTest.php

   1 <?php
   2
   3 namespace MediaWiki\Tests\Storage;
   4
   5 use CommentStoreComment;
   6 use Exception;
   7 use HashBagOStuff;
   8 use InvalidArgumentException;
   9 use MediaWiki\Linker\LinkTarget;
  10 use MediaWiki\MediaWikiServices;
  11 use MediaWiki\Storage\IncompleteRevisionException;
  12 use MediaWiki\Storage\MutableRevisionRecord;
  13 use MediaWiki\Storage\RevisionRecord;
  14 use MediaWiki\Storage\RevisionStore;
  15 use MediaWiki\Storage\SlotRecord;
  16 use MediaWiki\Storage\SqlBlobStore;
  17 use MediaWikiTestCase;
  18 use Revision;
  19 use TestUserRegistry;
  20 use Title;
  21 use WANObjectCache;
  22 use Wikimedia\Rdbms\Database;
  23 use Wikimedia\Rdbms\DatabaseSqlite;
  24 use Wikimedia\Rdbms\FakeResultWrapper;
  25 use Wikimedia\Rdbms\LoadBalancer;
  26 use Wikimedia\Rdbms\TransactionProfiler;
  27 use WikiPage;
  28 use WikitextContent;
  29
  30 /**
  31  * @group Database
  32  */
  33 class RevisionStoreDbTest extends MediaWikiTestCase {
  34
  35         /**
  36          * @return LoadBalancer
  37          */
  38         private function getLoadBalancerMock( array $server ) {
  39                 $lb = $this->getMockBuilder( LoadBalancer::class )
  40                         ->setMethods( [ 'reallyOpenConnection' ] )
  41                         ->setConstructorArgs( [ [ 'servers' => [ $server ] ] ] )
  42                         ->getMock();
  43
  44                 $lb->method( 'reallyOpenConnection' )->willReturnCallback(
  45                         function ( array $server, $dbNameOverride = false ) {
  46                                 return $this->getDatabaseMock( $server );
  47                         }
  48                 );
  49
  50                 return $lb;
  51         }
  52
  53         /**
  54          * @return Database
  55          */
  56         private function getDatabaseMock( array $params ) {
  57                 $db = $this->getMockBuilder( DatabaseSqlite::class )
  58                         ->setMethods( [ 'select', 'doQuery', 'open', 'closeConnection', 'isOpen' ] )
  59                         ->setConstructorArgs( [ $params ] )
  60                         ->getMock();
  61
  62                 $db->method( 'select' )->willReturn( new FakeResultWrapper( [] ) );
  63                 $db->method( 'isOpen' )->willReturn( true );
  64
  65                 return $db;
  66         }
  67
  68         public function provideDomainCheck() {
  69                 yield [ false, 'test', '' ];
  70                 yield [ 'test', 'test', '' ];
  71
  72                 yield [ false, 'test', 'foo_' ];
  73                 yield [ 'test-foo_', 'test', 'foo_' ];
  74
  75                 yield [ false, 'dash-test', '' ];
  76                 yield [ 'dash-test', 'dash-test', '' ];
  77
  78                 yield [ false, 'underscore_test', 'foo_' ];
  79                 yield [ 'underscore_test-foo_', 'underscore_test', 'foo_' ];
  80         }
  81
  82         /**
  83          * @dataProvider provideDomainCheck
  84          * @covers \MediaWiki\Storage\RevisionStore::checkDatabaseWikiId
  85          */
  86         public function testDomainCheck( $wikiId, $dbName, $dbPrefix ) {
  87                 $this->setMwGlobals(
  88                         [
  89                                 'wgDBname' => $dbName,
  90                                 'wgDBprefix' => $dbPrefix,
  91                         ]
  92                 );
  93
  94                 $loadBalancer = $this->getLoadBalancerMock(
  95                         [
  96                                 'host' => '*dummy*',
  97                                 'dbDirectory' => '*dummy*',
  98                                 'user' => 'test',
  99                                 'password' => 'test',
 100                                 'flags' => 0,
 101                                 'variables' => [],
 102                                 'schema' => '',
 103                                 'cliMode' => true,
 104                                 'agent' => '',
 105                                 'load' => 100,
 106                                 'profiler' => null,
 107                                 'trxProfiler' => new TransactionProfiler(),
 108                                 'connLogger' => new \Psr\Log\NullLogger(),
 109                                 'queryLogger' => new \Psr\Log\NullLogger(),
 110                                 'errorLogger' => new \Psr\Log\NullLogger(),
 111                                 'type' => 'test',
 112                                 'dbname' => $dbName,
 113                                 'tablePrefix' => $dbPrefix,
 114                         ]
 115                 );
 116                 $db = $loadBalancer->getConnection( DB_REPLICA );
 117
 118                 $blobStore = $this->getMockBuilder( SqlBlobStore::class )
 119                         ->disableOriginalConstructor()
 120                         ->getMock();
 121
 122                 $store = new RevisionStore(
 123                         $loadBalancer,
 124                         $blobStore,
 125                         new WANObjectCache( [ 'cache' => new HashBagOStuff() ] ),
 126                         $wikiId
 127                 );
 128
 129                 $count = $store->countRevisionsByPageId( $db, 0 );
 130
 131                 // Dummy check to make PhpUnit happy. We are really only interested in
 132                 // countRevisionsByPageId not failing due to the DB domain check.
 133                 $this->assertSame( 0, $count );
 134         }
 135
 136         private function assertLinkTargetsEqual( LinkTarget $l1, LinkTarget $l2 ) {
 137                 $this->assertEquals( $l1->getDBkey(), $l2->getDBkey() );
 138                 $this->assertEquals( $l1->getNamespace(), $l2->getNamespace() );
 139                 $this->assertEquals( $l1->getFragment(), $l2->getFragment() );
 140                 $this->assertEquals( $l1->getInterwiki(), $l2->getInterwiki() );
 141         }
 142
 143         private function assertRevisionRecordsEqual( RevisionRecord $r1, RevisionRecord $r2 ) {
 144                 $this->assertEquals( $r1->getUser()->getName(), $r2->getUser()->getName() );
 145                 $this->assertEquals( $r1->getUser()->getId(), $r2->getUser()->getId() );
 146                 $this->assertEquals( $r1->getComment(), $r2->getComment() );
 147                 $this->assertEquals( $r1->getPageAsLinkTarget(), $r2->getPageAsLinkTarget() );
 148                 $this->assertEquals( $r1->getTimestamp(), $r2->getTimestamp() );
 149                 $this->assertEquals( $r1->getVisibility(), $r2->getVisibility() );
 150                 $this->assertEquals( $r1->getSha1(), $r2->getSha1() );
 151                 $this->assertEquals( $r1->getParentId(), $r2->getParentId() );
 152                 $this->assertEquals( $r1->getSize(), $r2->getSize() );
 153                 $this->assertEquals( $r1->getPageId(), $r2->getPageId() );
 154                 $this->assertEquals( $r1->getSlotRoles(), $r2->getSlotRoles() );
 155                 $this->assertEquals( $r1->getWikiId(), $r2->getWikiId() );
 156                 $this->assertEquals( $r1->isMinor(), $r2->isMinor() );
 157                 foreach ( $r1->getSlotRoles() as $role ) {
 158                         $this->assertEquals( $r1->getSlot( $role ), $r2->getSlot( $role ) );
 159                         $this->assertEquals( $r1->getContent( $role ), $r2->getContent( $role ) );
 160                 }
 161                 foreach ( [
 162                         RevisionRecord::DELETED_TEXT,
 163                         RevisionRecord::DELETED_COMMENT,
 164                         RevisionRecord::DELETED_USER,
 165                         RevisionRecord::DELETED_RESTRICTED,
 166                 ] as $field ) {
 167                         $this->assertEquals( $r1->isDeleted( $field ), $r2->isDeleted( $field ) );
 168                 }
 169         }
 170
 171         /**
 172          * @param mixed[] $details
 173          *
 174          * @return RevisionRecord
 175          */
 176         private function getRevisionRecordFromDetailsArray( $title, $details = [] ) {
 177                 // Convert some values that can't be provided by dataProviders
 178                 $page = WikiPage::factory( $title );
 179                 if ( isset( $details['user'] ) && $details['user'] === true ) {
 180                         $details['user'] = $this->getTestUser()->getUser();
 181                 }
 182                 if ( isset( $details['page'] ) && $details['page'] === true ) {
 183                         $details['page'] = $page->getId();
 184                 }
 185                 if ( isset( $details['parent'] ) && $details['parent'] === true ) {
 186                         $details['parent'] = $page->getLatest();
 187                 }
 188
 189                 // Create the RevisionRecord with any available data
 190                 $rev = new MutableRevisionRecord( $title );
 191                 isset( $details['slot'] ) ? $rev->setSlot( $details['slot'] ) : null;
 192                 isset( $details['parent'] ) ? $rev->setParentId( $details['parent'] ) : null;
 193                 isset( $details['page'] ) ? $rev->setPageId( $details['page'] ) : null;
 194                 isset( $details['size'] ) ? $rev->setSize( $details['size'] ) : null;
 195                 isset( $details['sha1'] ) ? $rev->setSha1( $details['sha1'] ) : null;
 196                 isset( $details['comment'] ) ? $rev->setComment( $details['comment'] ) : null;
 197                 isset( $details['timestamp'] ) ? $rev->setTimestamp( $details['timestamp'] ) : null;
 198                 isset( $details['minor'] ) ? $rev->setMinorEdit( $details['minor'] ) : null;
 199                 isset( $details['user'] ) ? $rev->setUser( $details['user'] ) : null;
 200                 isset( $details['visibility'] ) ? $rev->setVisibility( $details['visibility'] ) : null;
 201                 isset( $details['id'] ) ? $rev->setId( $details['id'] ) : null;
 202
 203                 return $rev;
 204         }
 205
 206         private function getRandomCommentStoreComment() {
 207                 return CommentStoreComment::newUnsavedComment( __METHOD__ . '.' . rand( 0, 1000 ) );
 208         }
 209
 210         public function provideInsertRevisionOn_successes() {
 211                 yield 'Bare minimum revision insertion' => [
 212                         Title::newFromText( 'UTPage' ),
 213                         [
 214                                 'slot' => SlotRecord::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
 215                                 'parent' => true,
 216                                 'comment' => $this->getRandomCommentStoreComment(),
 217                                 'timestamp' => '20171117010101',
 218                                 'user' => true,
 219                         ],
 220                 ];
 221                 yield 'Detailed revision insertion' => [
 222                         Title::newFromText( 'UTPage' ),
 223                         [
 224                                 'slot' => SlotRecord::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
 225                                 'parent' => true,
 226                                 'page' => true,
 227                                 'comment' => $this->getRandomCommentStoreComment(),
 228                                 'timestamp' => '20171117010101',
 229                                 'user' => true,
 230                                 'minor' => true,
 231                                 'visibility' => RevisionRecord::DELETED_RESTRICTED,
 232                         ],
 233                 ];
 234         }
 235
 236         /**
 237          * @dataProvider provideInsertRevisionOn_successes
 238          * @covers \MediaWiki\Storage\RevisionStore::insertRevisionOn
 239          */
 240         public function testInsertRevisionOn_successes( Title $title, array $revDetails = [] ) {
 241                 $rev = $this->getRevisionRecordFromDetailsArray( $title, $revDetails );
 242
 243                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 244                 $return = $store->insertRevisionOn( $rev, wfGetDB( DB_MASTER ) );
 245
 246                 $this->assertLinkTargetsEqual( $title, $return->getPageAsLinkTarget() );
 247                 $this->assertRevisionRecordsEqual( $rev, $return );
 248         }
 249
 250         /**
 251          * @covers \MediaWiki\Storage\RevisionStore::insertRevisionOn
 252          */
 253         public function testInsertRevisionOn_blobAddressExists() {
 254                 $title = Title::newFromText( 'UTPage' );
 255                 $revDetails = [
 256                         'slot' => SlotRecord::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
 257                         'parent' => true,
 258                         'comment' => $this->getRandomCommentStoreComment(),
 259                         'timestamp' => '20171117010101',
 260                         'user' => true,
 261                 ];
 262
 263                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 264
 265                 // Insert the first revision
 266                 $revOne = $this->getRevisionRecordFromDetailsArray( $title, $revDetails );
 267                 $firstReturn = $store->insertRevisionOn( $revOne, wfGetDB( DB_MASTER ) );
 268                 $this->assertLinkTargetsEqual( $title, $firstReturn->getPageAsLinkTarget() );
 269                 $this->assertRevisionRecordsEqual( $revOne, $firstReturn );
 270
 271                 // Insert a second revision inheriting the same blob address
 272                 $revDetails['slot'] = SlotRecord::newInherited( $firstReturn->getSlot( 'main' ) );
 273                 $revTwo = $this->getRevisionRecordFromDetailsArray( $title, $revDetails );
 274                 $secondReturn = $store->insertRevisionOn( $revTwo, wfGetDB( DB_MASTER ) );
 275                 $this->assertLinkTargetsEqual( $title, $secondReturn->getPageAsLinkTarget() );
 276                 $this->assertRevisionRecordsEqual( $revTwo, $secondReturn );
 277
 278                 // Assert that the same blob address has been used.
 279                 $this->assertEquals(
 280                         $firstReturn->getSlot( 'main' )->getAddress(),
 281                         $secondReturn->getSlot( 'main' )->getAddress()
 282                 );
 283                 // And that different revisions have been created.
 284                 $this->assertNotSame(
 285                         $firstReturn->getId(),
 286                         $secondReturn->getId()
 287                 );
 288         }
 289
 290         public function provideInsertRevisionOn_failures() {
 291                 yield 'no slot' => [
 292                         Title::newFromText( 'UTPage' ),
 293                         [
 294                                 'comment' => $this->getRandomCommentStoreComment(),
 295                                 'timestamp' => '20171117010101',
 296                                 'user' => true,
 297                         ],
 298                         new InvalidArgumentException( 'At least one slot needs to be defined!' )
 299                 ];
 300                 yield 'slot that is not main slot' => [
 301                         Title::newFromText( 'UTPage' ),
 302                         [
 303                                 'slot' => SlotRecord::newUnsaved( 'lalala', new WikitextContent( 'Chicken' ) ),
 304                                 'comment' => $this->getRandomCommentStoreComment(),
 305                                 'timestamp' => '20171117010101',
 306                                 'user' => true,
 307                         ],
 308                         new InvalidArgumentException( 'Only the main slot is supported for now!' )
 309                 ];
 310                 yield 'no timestamp' => [
 311                         Title::newFromText( 'UTPage' ),
 312                         [
 313                                 'slot' => SlotRecord::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
 314                                 'comment' => $this->getRandomCommentStoreComment(),
 315                                 'user' => true,
 316                         ],
 317                         new IncompleteRevisionException( 'timestamp field must not be NULL!' )
 318                 ];
 319                 yield 'no comment' => [
 320                         Title::newFromText( 'UTPage' ),
 321                         [
 322                                 'slot' => SlotRecord::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
 323                                 'timestamp' => '20171117010101',
 324                                 'user' => true,
 325                         ],
 326                         new IncompleteRevisionException( 'comment must not be NULL!' )
 327                 ];
 328                 yield 'no user' => [
 329                         Title::newFromText( 'UTPage' ),
 330                         [
 331                                 'slot' => SlotRecord::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
 332                                 'comment' => $this->getRandomCommentStoreComment(),
 333                                 'timestamp' => '20171117010101',
 334                         ],
 335                         new IncompleteRevisionException( 'user must not be NULL!' )
 336                 ];
 337         }
 338
 339         /**
 340          * @dataProvider provideInsertRevisionOn_failures
 341          * @covers \MediaWiki\Storage\RevisionStore::insertRevisionOn
 342          */
 343         public function testInsertRevisionOn_failures(
 344                 Title $title,
 345                 array $revDetails = [],
 346                 Exception $exception ) {
 347                 $rev = $this->getRevisionRecordFromDetailsArray( $title, $revDetails );
 348
 349                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 350
 351                 $this->setExpectedException(
 352                         get_class( $exception ),
 353                         $exception->getMessage(),
 354                         $exception->getCode()
 355                 );
 356                 $store->insertRevisionOn( $rev, wfGetDB( DB_MASTER ) );
 357         }
 358
 359         public function provideNewNullRevision() {
 360                 yield [
 361                         Title::newFromText( 'UTPage' ),
 362                         CommentStoreComment::newUnsavedComment( __METHOD__ . ' comment1' ),
 363                         true,
 364                 ];
 365                 yield [
 366                         Title::newFromText( 'UTPage' ),
 367                         CommentStoreComment::newUnsavedComment( __METHOD__ . ' comment2', [ 'a' => 1 ] ),
 368                         false,
 369                 ];
 370         }
 371
 372         /**
 373          * @dataProvider provideNewNullRevision
 374          * @covers \MediaWiki\Storage\RevisionStore::newNullRevision
 375          */
 376         public function testNewNullRevision( Title $title, $comment, $minor ) {
 377                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 378                 $user = TestUserRegistry::getMutableTestUser( __METHOD__ )->getUser();
 379                 $record = $store->newNullRevision(
 380                         wfGetDB( DB_MASTER ),
 381                         $title,
 382                         $comment,
 383                         $minor,
 384                         $user
 385                 );
 386
 387                 $this->assertEquals( $title->getNamespace(), $record->getPageAsLinkTarget()->getNamespace() );
 388                 $this->assertEquals( $title->getDBkey(), $record->getPageAsLinkTarget()->getDBkey() );
 389                 $this->assertEquals( $comment, $record->getComment() );
 390                 $this->assertEquals( $minor, $record->isMinor() );
 391                 $this->assertEquals( $user->getName(), $record->getUser()->getName() );
 392         }
 393
 394         /**
 395          * @covers \MediaWiki\Storage\RevisionStore::newNullRevision
 396          */
 397         public function testNewNullRevision_nonExistingTitle() {
 398                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 399                 $record = $store->newNullRevision(
 400                         wfGetDB( DB_MASTER ),
 401                         Title::newFromText( __METHOD__ . '.iDontExist!' ),
 402                         CommentStoreComment::newUnsavedComment( __METHOD__ . ' comment' ),
 403                         false,
 404                         TestUserRegistry::getMutableTestUser( __METHOD__ )->getUser()
 405                 );
 406                 $this->assertNull( $record );
 407         }
 408
 409         /**
 410          * @covers \MediaWiki\Storage\RevisionStore::getRcIdIfUnpatrolled
 411          */
 412         public function testGetRcIdIfUnpatrolled_returnsRecentChangesId() {
 413                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 414                 $status = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ );
 415                 /** @var Revision $rev */
 416                 $rev = $status->value['revision'];
 417
 418                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 419                 $revisionRecord = $store->getRevisionById( $rev->getId() );
 420                 $result = $store->getRcIdIfUnpatrolled( $revisionRecord );
 421
 422                 $this->assertGreaterThan( 0, $result );
 423                 $this->assertSame(
 424                         $page->getRevision()->getRecentChange()->getAttribute( 'rc_id' ),
 425                         $result
 426                 );
 427         }
 428
 429         /**
 430          * @covers \MediaWiki\Storage\RevisionStore::getRcIdIfUnpatrolled
 431          */
 432         public function testGetRcIdIfUnpatrolled_returnsZeroIfPatrolled() {
 433                 // This assumes that sysops are auto patrolled
 434                 $sysop = $this->getTestSysop()->getUser();
 435                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 436                 $status = $page->doEditContent(
 437                         new WikitextContent( __METHOD__ ),
 438                         __METHOD__,
 439                         0,
 440                         false,
 441                         $sysop
 442                 );
 443                 /** @var Revision $rev */
 444                 $rev = $status->value['revision'];
 445
 446                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 447                 $revisionRecord = $store->getRevisionById( $rev->getId() );
 448                 $result = $store->getRcIdIfUnpatrolled( $revisionRecord );
 449
 450                 $this->assertSame( 0, $result );
 451         }
 452
 453         /**
 454          * @covers \MediaWiki\Storage\RevisionStore::getRecentChange
 455          */
 456         public function testGetRecentChange() {
 457                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 458                 $content = new WikitextContent( __METHOD__ );
 459                 $status = $page->doEditContent( $content, __METHOD__ );
 460                 /** @var Revision $rev */
 461                 $rev = $status->value['revision'];
 462
 463                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 464                 $revRecord = $store->getRevisionById( $rev->getId() );
 465                 $recentChange = $store->getRecentChange( $revRecord );
 466
 467                 $this->assertEquals( $rev->getId(), $recentChange->getAttribute( 'rc_this_oldid' ) );
 468                 $this->assertEquals( $rev->getRecentChange(), $recentChange );
 469         }
 470
 471         /**
 472          * @covers \MediaWiki\Storage\RevisionStore::getRevisionById
 473          */
 474         public function testGetRevisionById() {
 475                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 476                 $content = new WikitextContent( __METHOD__ );
 477                 $status = $page->doEditContent( $content, __METHOD__ );
 478                 /** @var Revision $rev */
 479                 $rev = $status->value['revision'];
 480
 481                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 482                 $revRecord = $store->getRevisionById( $rev->getId() );
 483
 484                 $this->assertSame( $rev->getId(), $revRecord->getId() );
 485                 $this->assertTrue( $revRecord->getSlot( 'main' )->getContent()->equals( $content ) );
 486                 $this->assertSame( __METHOD__, $revRecord->getComment()->text );
 487         }
 488
 489         /**
 490          * @covers \MediaWiki\Storage\RevisionStore::getRevisionByTitle
 491          */
 492         public function testGetRevisionByTitle() {
 493                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 494                 $content = new WikitextContent( __METHOD__ );
 495                 $status = $page->doEditContent( $content, __METHOD__ );
 496                 /** @var Revision $rev */
 497                 $rev = $status->value['revision'];
 498
 499                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 500                 $revRecord = $store->getRevisionByTitle( $page->getTitle() );
 501
 502                 $this->assertSame( $rev->getId(), $revRecord->getId() );
 503                 $this->assertTrue( $revRecord->getSlot( 'main' )->getContent()->equals( $content ) );
 504                 $this->assertSame( __METHOD__, $revRecord->getComment()->text );
 505         }
 506
 507         /**
 508          * @covers \MediaWiki\Storage\RevisionStore::getRevisionByPageId
 509          */
 510         public function testGetRevisionByPageId() {
 511                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 512                 $content = new WikitextContent( __METHOD__ );
 513                 $status = $page->doEditContent( $content, __METHOD__ );
 514                 /** @var Revision $rev */
 515                 $rev = $status->value['revision'];
 516
 517                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 518                 $revRecord = $store->getRevisionByPageId( $page->getId() );
 519
 520                 $this->assertSame( $rev->getId(), $revRecord->getId() );
 521                 $this->assertTrue( $revRecord->getSlot( 'main' )->getContent()->equals( $content ) );
 522                 $this->assertSame( __METHOD__, $revRecord->getComment()->text );
 523         }
 524
 525         /**
 526          * @covers \MediaWiki\Storage\RevisionStore::getRevisionByTimestamp
 527          */
 528         public function testGetRevisionByTimestamp() {
 529                 // Make sure there is 1 second between the last revision and the rev we create...
 530                 // Otherwise we might not get the correct revision and the test may fail...
 531                 // :(
 532                 sleep( 1 );
 533                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 534                 $content = new WikitextContent( __METHOD__ );
 535                 $status = $page->doEditContent( $content, __METHOD__ );
 536                 /** @var Revision $rev */
 537                 $rev = $status->value['revision'];
 538
 539                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 540                 $revRecord = $store->getRevisionByTimestamp(
 541                         $page->getTitle(),
 542                         $rev->getTimestamp()
 543                 );
 544
 545                 $this->assertSame( $rev->getId(), $revRecord->getId() );
 546                 $this->assertTrue( $revRecord->getSlot( 'main' )->getContent()->equals( $content ) );
 547                 $this->assertSame( __METHOD__, $revRecord->getComment()->text );
 548         }
 549
 550         private function revisionToRow( Revision $rev ) {
 551                 $page = WikiPage::factory( $rev->getTitle() );
 552
 553                 return (object)[
 554                         'rev_id' => (string)$rev->getId(),
 555                         'rev_page' => (string)$rev->getPage(),
 556                         'rev_text_id' => (string)$rev->getTextId(),
 557                         'rev_timestamp' => (string)$rev->getTimestamp(),
 558                         'rev_user_text' => (string)$rev->getUserText(),
 559                         'rev_user' => (string)$rev->getUser(),
 560                         'rev_minor_edit' => $rev->isMinor() ? '1' : '0',
 561                         'rev_deleted' => (string)$rev->getVisibility(),
 562                         'rev_len' => (string)$rev->getSize(),
 563                         'rev_parent_id' => (string)$rev->getParentId(),
 564                         'rev_sha1' => (string)$rev->getSha1(),
 565                         'rev_comment_text' => $rev->getComment(),
 566                         'rev_comment_data' => null,
 567                         'rev_comment_cid' => null,
 568                         'rev_content_format' => $rev->getContentFormat(),
 569                         'rev_content_model' => $rev->getContentModel(),
 570                         'page_namespace' => (string)$page->getTitle()->getNamespace(),
 571                         'page_title' => $page->getTitle()->getDBkey(),
 572                         'page_id' => (string)$page->getId(),
 573                         'page_latest' => (string)$page->getLatest(),
 574                         'page_is_redirect' => $page->isRedirect() ? '1' : '0',
 575                         'page_len' => (string)$page->getContent()->getSize(),
 576                         'user_name' => (string)$rev->getUserText(),
 577                 ];
 578         }
 579
 580         private function assertRevisionRecordMatchesRevision(
 581                 Revision $rev,
 582                 RevisionRecord $record
 583         ) {
 584                 $this->assertSame( $rev->getId(), $record->getId() );
 585                 $this->assertSame( $rev->getPage(), $record->getPageId() );
 586                 $this->assertSame( $rev->getTimestamp(), $record->getTimestamp() );
 587                 $this->assertSame( $rev->getUserText(), $record->getUser()->getName() );
 588                 $this->assertSame( $rev->getUser(), $record->getUser()->getId() );
 589                 $this->assertSame( $rev->isMinor(), $record->isMinor() );
 590                 $this->assertSame( $rev->getVisibility(), $record->getVisibility() );
 591                 $this->assertSame( $rev->getSize(), $record->getSize() );
 592                 /**
 593                  * @note As of MW 1.31, the database schema allows the parent ID to be
 594                  * NULL to indicate that it is unknown.
 595                  */
 596                 $expectedParent = $rev->getParentId();
 597                 if ( $expectedParent === null ) {
 598                         $expectedParent = 0;
 599                 }
 600                 $this->assertSame( $expectedParent, $record->getParentId() );
 601                 $this->assertSame( $rev->getSha1(), $record->getSha1() );
 602                 $this->assertSame( $rev->getComment(), $record->getComment()->text );
 603                 $this->assertSame( $rev->getContentFormat(), $record->getContent( 'main' )->getDefaultFormat() );
 604                 $this->assertSame( $rev->getContentModel(), $record->getContent( 'main' )->getModel() );
 605                 $this->assertLinkTargetsEqual( $rev->getTitle(), $record->getPageAsLinkTarget() );
 606         }
 607
 608         /**
 609          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow
 610          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow_1_29
 611          */
 612         public function testNewRevisionFromRow_anonEdit() {
 613                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 614                 /** @var Revision $rev */
 615                 $rev = $page->doEditContent(
 616                         new WikitextContent( __METHOD__. 'a' ),
 617                         __METHOD__. 'a'
 618                 )->value['revision'];
 619
 620                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 621                 $record = $store->newRevisionFromRow(
 622                         $this->revisionToRow( $rev ),
 623                         [],
 624                         $page->getTitle()
 625                 );
 626                 $this->assertRevisionRecordMatchesRevision( $rev, $record );
 627         }
 628
 629         /**
 630          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow
 631          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow_1_29
 632          */
 633         public function testNewRevisionFromRow_userEdit() {
 634                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 635                 /** @var Revision $rev */
 636                 $rev = $page->doEditContent(
 637                         new WikitextContent( __METHOD__. 'b' ),
 638                         __METHOD__ . 'b',
 639                         0,
 640                         false,
 641                         $this->getTestUser()->getUser()
 642                 )->value['revision'];
 643
 644                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 645                 $record = $store->newRevisionFromRow(
 646                         $this->revisionToRow( $rev ),
 647                         [],
 648                         $page->getTitle()
 649                 );
 650                 $this->assertRevisionRecordMatchesRevision( $rev, $record );
 651         }
 652
 653         /**
 654          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromArchiveRow
 655          */
 656         public function testNewRevisionFromArchiveRow() {
 657                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 658                 $title = Title::newFromText( __METHOD__ );
 659                 $page = WikiPage::factory( $title );
 660                 /** @var Revision $orig */
 661                 $orig = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
 662                         ->value['revision'];
 663                 $page->doDeleteArticle( __METHOD__ );
 664
 665                 $db = wfGetDB( DB_MASTER );
 666                 $arQuery = $store->getArchiveQueryInfo();
 667                 $res = $db->select(
 668                         $arQuery['tables'], $arQuery['fields'], [ 'ar_rev_id' => $orig->getId() ],
 669                         __METHOD__, [], $arQuery['joins']
 670                 );
 671                 $this->assertTrue( is_object( $res ), 'query failed' );
 672
 673                 $row = $res->fetchObject();
 674                 $res->free();
 675                 $record = $store->newRevisionFromArchiveRow( $row );
 676
 677                 $this->assertRevisionRecordMatchesRevision( $orig, $record );
 678         }
 679
 680         /**
 681          * @covers \MediaWiki\Storage\RevisionStore::loadRevisionFromId
 682          */
 683         public function testLoadRevisionFromId() {
 684                 $title = Title::newFromText( __METHOD__ );
 685                 $page = WikiPage::factory( $title );
 686                 /** @var Revision $rev */
 687                 $rev = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
 688                         ->value['revision'];
 689
 690                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 691                 $result = $store->loadRevisionFromId( wfGetDB( DB_MASTER ), $rev->getId() );
 692                 $this->assertRevisionRecordMatchesRevision( $rev, $result );
 693         }
 694
 695         /**
 696          * @covers \MediaWiki\Storage\RevisionStore::loadRevisionFromPageId
 697          */
 698         public function testLoadRevisionFromPageId() {
 699                 $title = Title::newFromText( __METHOD__ );
 700                 $page = WikiPage::factory( $title );
 701                 /** @var Revision $rev */
 702                 $rev = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
 703                         ->value['revision'];
 704
 705                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 706                 $result = $store->loadRevisionFromPageId( wfGetDB( DB_MASTER ), $page->getId() );
 707                 $this->assertRevisionRecordMatchesRevision( $rev, $result );
 708         }
 709
 710         /**
 711          * @covers \MediaWiki\Storage\RevisionStore::loadRevisionFromTitle
 712          */
 713         public function testLoadRevisionFromTitle() {
 714                 $title = Title::newFromText( __METHOD__ );
 715                 $page = WikiPage::factory( $title );
 716                 /** @var Revision $rev */
 717                 $rev = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
 718                         ->value['revision'];
 719
 720                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 721                 $result = $store->loadRevisionFromTitle( wfGetDB( DB_MASTER ), $title );
 722                 $this->assertRevisionRecordMatchesRevision( $rev, $result );
 723         }
 724
 725         /**
 726          * @covers \MediaWiki\Storage\RevisionStore::loadRevisionFromTimestamp
 727          */
 728         public function testLoadRevisionFromTimestamp() {
 729                 $title = Title::newFromText( __METHOD__ );
 730                 $page = WikiPage::factory( $title );
 731                 /** @var Revision $revOne */
 732                 $revOne = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
 733                         ->value['revision'];
 734                 // Sleep to ensure different timestamps... )(evil)
 735                 sleep( 1 );
 736                 /** @var Revision $revTwo */
 737                 $revTwo = $page->doEditContent( new WikitextContent( __METHOD__ . 'a' ), '' )
 738                         ->value['revision'];
 739
 740                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 741                 $this->assertNull(
 742                         $store->loadRevisionFromTimestamp( wfGetDB( DB_MASTER ), $title, '20150101010101' )
 743                 );
 744                 $this->assertSame(
 745                         $revOne->getId(),
 746                         $store->loadRevisionFromTimestamp(
 747                                 wfGetDB( DB_MASTER ),
 748                                 $title,
 749                                 $revOne->getTimestamp()
 750                         )->getId()
 751                 );
 752                 $this->assertSame(
 753                         $revTwo->getId(),
 754                         $store->loadRevisionFromTimestamp(
 755                                 wfGetDB( DB_MASTER ),
 756                                 $title,
 757                                 $revTwo->getTimestamp()
 758                         )->getId()
 759                 );
 760         }
 761
 762         /**
 763          * @covers \MediaWiki\Storage\RevisionStore::listRevisionSizes
 764          */
 765         public function testGetParentLengths() {
 766                 $page = WikiPage::factory( Title::newFromText( __METHOD__ ) );
 767                 /** @var Revision $revOne */
 768                 $revOne = $page->doEditContent(
 769                         new WikitextContent( __METHOD__ ), __METHOD__
 770                 )->value['revision'];
 771                 /** @var Revision $revTwo */
 772                 $revTwo = $page->doEditContent(
 773                         new WikitextContent( __METHOD__ . '2' ), __METHOD__
 774                 )->value['revision'];
 775
 776                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 777                 $this->assertSame(
 778                         [
 779                                 $revOne->getId() => strlen( __METHOD__ ),
 780                         ],
 781                         $store->listRevisionSizes(
 782                                 wfGetDB( DB_MASTER ),
 783                                 [ $revOne->getId() ]
 784                         )
 785                 );
 786                 $this->assertSame(
 787                         [
 788                                 $revOne->getId() => strlen( __METHOD__ ),
 789                                 $revTwo->getId() => strlen( __METHOD__ ) + 1,
 790                         ],
 791                         $store->listRevisionSizes(
 792                                 wfGetDB( DB_MASTER ),
 793                                 [ $revOne->getId(), $revTwo->getId() ]
 794                         )
 795                 );
 796         }
 797
 798         /**
 799          * @covers \MediaWiki\Storage\RevisionStore::getPreviousRevision
 800          */
 801         public function testGetPreviousRevision() {
 802                 $page = WikiPage::factory( Title::newFromText( __METHOD__ ) );
 803                 /** @var Revision $revOne */
 804                 $revOne = $page->doEditContent(
 805                         new WikitextContent( __METHOD__ ), __METHOD__
 806                 )->value['revision'];
 807                 /** @var Revision $revTwo */
 808                 $revTwo = $page->doEditContent(
 809                         new WikitextContent( __METHOD__ . '2' ), __METHOD__
 810                 )->value['revision'];
 811
 812                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 813                 $this->assertNull(
 814                         $store->getPreviousRevision( $store->getRevisionById( $revOne->getId() ) )
 815                 );
 816                 $this->assertSame(
 817                         $revOne->getId(),
 818                         $store->getPreviousRevision( $store->getRevisionById( $revTwo->getId() ) )->getId()
 819                 );
 820         }
 821
 822         /**
 823          * @covers \MediaWiki\Storage\RevisionStore::getNextRevision
 824          */
 825         public function testGetNextRevision() {
 826                 $page = WikiPage::factory( Title::newFromText( __METHOD__ ) );
 827                 /** @var Revision $revOne */
 828                 $revOne = $page->doEditContent(
 829                         new WikitextContent( __METHOD__ ), __METHOD__
 830                 )->value['revision'];
 831                 /** @var Revision $revTwo */
 832                 $revTwo = $page->doEditContent(
 833                         new WikitextContent( __METHOD__ . '2' ), __METHOD__
 834                 )->value['revision'];
 835
 836                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 837                 $this->assertSame(
 838                         $revTwo->getId(),
 839                         $store->getNextRevision( $store->getRevisionById( $revOne->getId() ) )->getId()
 840                 );
 841                 $this->assertNull(
 842                         $store->getNextRevision( $store->getRevisionById( $revTwo->getId() ) )
 843                 );
 844         }
 845
 846         /**
 847          * @covers \MediaWiki\Storage\RevisionStore::getTimestampFromId
 848          */
 849         public function testGetTimestampFromId_found() {
 850                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 851                 /** @var Revision $rev */
 852                 $rev = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
 853                         ->value['revision'];
 854
 855                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 856                 $result = $store->getTimestampFromId(
 857                         $page->getTitle(),
 858                         $rev->getId()
 859                 );
 860
 861                 $this->assertSame( $rev->getTimestamp(), $result );
 862         }
 863
 864         /**
 865          * @covers \MediaWiki\Storage\RevisionStore::getTimestampFromId
 866          */
 867         public function testGetTimestampFromId_notFound() {
 868                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 869                 /** @var Revision $rev */
 870                 $rev = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
 871                         ->value['revision'];
 872
 873                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 874                 $result = $store->getTimestampFromId(
 875                         $page->getTitle(),
 876                         $rev->getId() + 1
 877                 );
 878
 879                 $this->assertFalse( $result );
 880         }
 881
 882         /**
 883          * @covers \MediaWiki\Storage\RevisionStore::countRevisionsByPageId
 884          */
 885         public function testCountRevisionsByPageId() {
 886                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 887                 $page = WikiPage::factory( Title::newFromText( __METHOD__ ) );
 888
 889                 $this->assertSame(
 890                         0,
 891                         $store->countRevisionsByPageId( wfGetDB( DB_MASTER ), $page->getId() )
 892                 );
 893                 $page->doEditContent( new WikitextContent( 'a' ), 'a' );
 894                 $this->assertSame(
 895                         1,
 896                         $store->countRevisionsByPageId( wfGetDB( DB_MASTER ), $page->getId() )
 897                 );
 898                 $page->doEditContent( new WikitextContent( 'b' ), 'b' );
 899                 $this->assertSame(
 900                         2,
 901                         $store->countRevisionsByPageId( wfGetDB( DB_MASTER ), $page->getId() )
 902                 );
 903         }
 904
 905         /**
 906          * @covers \MediaWiki\Storage\RevisionStore::countRevisionsByTitle
 907          */
 908         public function testCountRevisionsByTitle() {
 909                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 910                 $page = WikiPage::factory( Title::newFromText( __METHOD__ ) );
 911
 912                 $this->assertSame(
 913                         0,
 914                         $store->countRevisionsByTitle( wfGetDB( DB_MASTER ), $page->getTitle() )
 915                 );
 916                 $page->doEditContent( new WikitextContent( 'a' ), 'a' );
 917                 $this->assertSame(
 918                         1,
 919                         $store->countRevisionsByTitle( wfGetDB( DB_MASTER ), $page->getTitle() )
 920                 );
 921                 $page->doEditContent( new WikitextContent( 'b' ), 'b' );
 922                 $this->assertSame(
 923                         2,
 924                         $store->countRevisionsByTitle( wfGetDB( DB_MASTER ), $page->getTitle() )
 925                 );
 926         }
 927
 928         /**
 929          * @covers \MediaWiki\Storage\RevisionStore::userWasLastToEdit
 930          */
 931         public function testUserWasLastToEdit_false() {
 932                 $sysop = $this->getTestSysop()->getUser();
 933                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 934                 $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ );
 935
 936                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 937                 $result = $store->userWasLastToEdit(
 938                         wfGetDB( DB_MASTER ),
 939                         $page->getId(),
 940                         $sysop->getId(),
 941                         '20160101010101'
 942                 );
 943                 $this->assertFalse( $result );
 944         }
 945
 946         /**
 947          * @covers \MediaWiki\Storage\RevisionStore::userWasLastToEdit
 948          */
 949         public function testUserWasLastToEdit_true() {
 950                 $startTime = wfTimestampNow();
 951                 $sysop = $this->getTestSysop()->getUser();
 952                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 953                 $page->doEditContent(
 954                         new WikitextContent( __METHOD__ ),
 955                         __METHOD__,
 956                         0,
 957                         false,
 958                         $sysop
 959                 );
 960
 961                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 962                 $result = $store->userWasLastToEdit(
 963                         wfGetDB( DB_MASTER ),
 964                         $page->getId(),
 965                         $sysop->getId(),
 966                         $startTime
 967                 );
 968                 $this->assertTrue( $result );
 969         }
 970
 971         /**
 972          * @covers \MediaWiki\Storage\RevisionStore::getKnownCurrentRevision
 973          */
 974         public function testGetKnownCurrentRevision() {
 975                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 976                 /** @var Revision $rev */
 977                 $rev = $page->doEditContent(
 978                         new WikitextContent( __METHOD__. 'b' ),
 979                         __METHOD__ . 'b',
 980                         0,
 981                         false,
 982                         $this->getTestUser()->getUser()
 983                 )->value['revision'];
 984
 985                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 986                 $record = $store->getKnownCurrentRevision(
 987                         $page->getTitle(),
 988                         $rev->getId()
 989                 );
 990
 991                 $this->assertRevisionRecordMatchesRevision( $rev, $record );
 992         }
 993
 994         public function provideNewMutableRevisionFromArray() {
 995                 yield 'Basic array, with page & id' => [
 996                         [
 997                                 'id' => 2,
 998                                 'page' => 1,
 999                                 'text_id' => 2,
1000                                 'timestamp' => '20171017114835',
1001                                 'user_text' => '111.0.1.2',
1002                                 'user' => 0,
1003                                 'minor_edit' => false,
1004                                 'deleted' => 0,
1005                                 'len' => 46,
1006                                 'parent_id' => 1,
1007                                 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1008                                 'comment' => 'Goat Comment!',
1009                                 'content_format' => 'text/x-wiki',
1010                                 'content_model' => 'wikitext',
1011                         ]
1012                 ];
1013                 yield 'Basic array, content object' => [
1014                         [
1015                                 'id' => 2,
1016                                 'page' => 1,
1017                                 'timestamp' => '20171017114835',
1018                                 'user_text' => '111.0.1.2',
1019                                 'user' => 0,
1020                                 'minor_edit' => false,
1021                                 'deleted' => 0,
1022                                 'len' => 46,
1023                                 'parent_id' => 1,
1024                                 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1025                                 'comment' => 'Goat Comment!',
1026                                 'content' => new WikitextContent( 'Some Content' ),
1027                         ]
1028                 ];
1029                 yield 'Basic array, with title' => [
1030                         [
1031                                 'title' => Title::newFromText( 'SomeText' ),
1032                                 'text_id' => 2,
1033                                 'timestamp' => '20171017114835',
1034                                 'user_text' => '111.0.1.2',
1035                                 'user' => 0,
1036                                 'minor_edit' => false,
1037                                 'deleted' => 0,
1038                                 'len' => 46,
1039                                 'parent_id' => 1,
1040                                 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1041                                 'comment' => 'Goat Comment!',
1042                                 'content_format' => 'text/x-wiki',
1043                                 'content_model' => 'wikitext',
1044                         ]
1045                 ];
1046                 yield 'Basic array, no user field' => [
1047                         [
1048                                 'id' => 2,
1049                                 'page' => 1,
1050                                 'text_id' => 2,
1051                                 'timestamp' => '20171017114835',
1052                                 'user_text' => '111.0.1.3',
1053                                 'minor_edit' => false,
1054                                 'deleted' => 0,
1055                                 'len' => 46,
1056                                 'parent_id' => 1,
1057                                 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1058                                 'comment' => 'Goat Comment!',
1059                                 'content_format' => 'text/x-wiki',
1060                                 'content_model' => 'wikitext',
1061                         ]
1062                 ];
1063         }
1064
1065         /**
1066          * @dataProvider provideNewMutableRevisionFromArray
1067          * @covers \MediaWiki\Storage\RevisionStore::newMutableRevisionFromArray
1068          */
1069         public function testNewMutableRevisionFromArray( array $array ) {
1070                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1071
1072                 $result = $store->newMutableRevisionFromArray( $array );
1073
1074                 if ( isset( $array['id'] ) ) {
1075                         $this->assertSame( $array['id'], $result->getId() );
1076                 }
1077                 if ( isset( $array['page'] ) ) {
1078                         $this->assertSame( $array['page'], $result->getPageId() );
1079                 }
1080                 $this->assertSame( $array['timestamp'], $result->getTimestamp() );
1081                 $this->assertSame( $array['user_text'], $result->getUser()->getName() );
1082                 if ( isset( $array['user'] ) ) {
1083                         $this->assertSame( $array['user'], $result->getUser()->getId() );
1084                 }
1085                 $this->assertSame( (bool)$array['minor_edit'], $result->isMinor() );
1086                 $this->assertSame( $array['deleted'], $result->getVisibility() );
1087                 $this->assertSame( $array['len'], $result->getSize() );
1088                 $this->assertSame( $array['parent_id'], $result->getParentId() );
1089                 $this->assertSame( $array['sha1'], $result->getSha1() );
1090                 $this->assertSame( $array['comment'], $result->getComment()->text );
1091                 if ( isset( $array['content'] ) ) {
1092                         $this->assertTrue(
1093                                 $result->getSlot( 'main' )->getContent()->equals( $array['content'] )
1094                         );
1095                 } else {
1096                         $this->assertSame(
1097                                 $array['content_format'],
1098                                 $result->getSlot( 'main' )->getContent()->getDefaultFormat()
1099                         );
1100                         $this->assertSame( $array['content_model'], $result->getSlot( 'main' )->getModel() );
1101                 }
1102         }
1103
1104 }