tests/phpunit/includes/api/ApiQueryWatchlistIntegrationTest.php

   1 <?php
   2
   3 use MediaWiki\Linker\LinkTarget;
   4 use MediaWiki\MediaWikiServices;
   5
   6 /**
   7  * @group API
   8  * @group Database
   9  * @group medium
  10  *
  11  * @covers ApiQueryWatchlist
  12  */
  13 class ApiQueryWatchlistIntegrationTest extends ApiTestCase {
  14
  15         public function __construct( $name = null, array $data = [], $dataName = '' ) {
  16                 parent::__construct( $name, $data, $dataName );
  17                 $this->tablesUsed = array_unique(
  18                         array_merge( $this->tablesUsed, [ 'watchlist', 'recentchanges', 'page' ] )
  19                 );
  20         }
  21
  22         protected function setUp() {
  23                 parent::setUp();
  24                 self::$users['ApiQueryWatchlistIntegrationTestUser'] = $this->getMutableTestUser();
  25                 self::$users['ApiQueryWatchlistIntegrationTestUser2'] = $this->getMutableTestUser();
  26                 $this->doLogin( 'ApiQueryWatchlistIntegrationTestUser' );
  27         }
  28
  29         private function getLoggedInTestUser() {
  30                 return self::$users['ApiQueryWatchlistIntegrationTestUser']->getUser();
  31         }
  32
  33         private function getNonLoggedInTestUser() {
  34                 return self::$users['ApiQueryWatchlistIntegrationTestUser2']->getUser();
  35         }
  36
  37         private function doPageEdit( User $user, LinkTarget $target, $content, $summary ) {
  38                 $title = Title::newFromLinkTarget( $target );
  39                 $page = WikiPage::factory( $title );
  40                 $page->doEditContent(
  41                         ContentHandler::makeContent( $content, $title ),
  42                         $summary,
  43                         0,
  44                         false,
  45                         $user
  46                 );
  47         }
  48
  49         private function doMinorPageEdit( User $user, LinkTarget $target, $content, $summary ) {
  50                 $title = Title::newFromLinkTarget( $target );
  51                 $page = WikiPage::factory( $title );
  52                 $page->doEditContent(
  53                         ContentHandler::makeContent( $content, $title ),
  54                         $summary,
  55                         EDIT_MINOR,
  56                         false,
  57                         $user
  58                 );
  59         }
  60
  61         private function doBotPageEdit( User $user, LinkTarget $target, $content, $summary ) {
  62                 $title = Title::newFromLinkTarget( $target );
  63                 $page = WikiPage::factory( $title );
  64                 $page->doEditContent(
  65                         ContentHandler::makeContent( $content, $title ),
  66                         $summary,
  67                         EDIT_FORCE_BOT,
  68                         false,
  69                         $user
  70                 );
  71         }
  72
  73         private function doAnonPageEdit( LinkTarget $target, $content, $summary ) {
  74                 $title = Title::newFromLinkTarget( $target );
  75                 $page = WikiPage::factory( $title );
  76                 $page->doEditContent(
  77                         ContentHandler::makeContent( $content, $title ),
  78                         $summary,
  79                         0,
  80                         false,
  81                         User::newFromId( 0 )
  82                 );
  83         }
  84
  85         private function doPatrolledPageEdit(
  86                 User $user,
  87                 LinkTarget $target,
  88                 $content,
  89                 $summary,
  90                 User $patrollingUser
  91         ) {
  92                 $title = Title::newFromLinkTarget( $target );
  93                 $page = WikiPage::factory( $title );
  94                 $status = $page->doEditContent(
  95                         ContentHandler::makeContent( $content, $title ),
  96                         $summary,
  97                         0,
  98                         false,
  99                         $user
 100                 );
 101                 /** @var Revision $rev */
 102                 $rev = $status->value['revision'];
 103                 $rc = $rev->getRecentChange();
 104                 $rc->doMarkPatrolled( $patrollingUser, false, [] );
 105         }
 106
 107         private function deletePage( LinkTarget $target, $reason ) {
 108                 $title = Title::newFromLinkTarget( $target );
 109                 $page = WikiPage::factory( $title );
 110                 $page->doDeleteArticleReal( $reason );
 111         }
 112
 113         /**
 114          * Performs a batch of page edits as a specified user
 115          * @param User $user
 116          * @param array $editData associative array, keys:
 117          *                        - target    => LinkTarget page to edit
 118          *                        - content   => string new content
 119          *                        - summary   => string edit summary
 120          *                        - minorEdit => bool mark as minor edit if true (defaults to false)
 121          *                        - botEdit   => bool mark as bot edit if true (defaults to false)
 122          */
 123         private function doPageEdits( User $user, array $editData ) {
 124                 foreach ( $editData as $singleEditData ) {
 125                         if ( array_key_exists( 'minorEdit', $singleEditData ) && $singleEditData['minorEdit'] ) {
 126                                 $this->doMinorPageEdit(
 127                                         $user,
 128                                         $singleEditData['target'],
 129                                         $singleEditData['content'],
 130                                         $singleEditData['summary']
 131                                 );
 132                                 continue;
 133                         }
 134                         if ( array_key_exists( 'botEdit', $singleEditData ) && $singleEditData['botEdit'] ) {
 135                                 $this->doBotPageEdit(
 136                                         $user,
 137                                         $singleEditData['target'],
 138                                         $singleEditData['content'],
 139                                         $singleEditData['summary']
 140                                 );
 141                                 continue;
 142                         }
 143                         $this->doPageEdit(
 144                                 $user,
 145                                 $singleEditData['target'],
 146                                 $singleEditData['content'],
 147                                 $singleEditData['summary']
 148                         );
 149                 }
 150         }
 151
 152         private function getWatchedItemStore() {
 153                 return MediaWikiServices::getInstance()->getWatchedItemStore();
 154         }
 155
 156         /**
 157          * @param User $user
 158          * @param LinkTarget[] $targets
 159          */
 160         private function watchPages( User $user, array $targets ) {
 161                 $store = $this->getWatchedItemStore();
 162                 $store->addWatchBatchForUser( $user, $targets );
 163         }
 164
 165         private function doListWatchlistRequest( array $params = [], $user = null ) {
 166                 return $this->doApiRequest(
 167                         array_merge(
 168                                 [ 'action' => 'query', 'list' => 'watchlist' ],
 169                                 $params
 170                         ), null, false, $user
 171                 );
 172         }
 173
 174         private function doGeneratorWatchlistRequest( array $params = [] ) {
 175                 return $this->doApiRequest(
 176                         array_merge(
 177                                 [ 'action' => 'query', 'generator' => 'watchlist' ],
 178                                 $params
 179                         )
 180                 );
 181         }
 182
 183         private function getItemsFromApiResponse( array $response ) {
 184                 return $response[0]['query']['watchlist'];
 185         }
 186
 187         /**
 188          * Convenience method to assert that actual items array fetched from API is equal to the expected
 189          * array, Unlike assertEquals this only checks if values of specified keys are equal in both
 190          * arrays. This could be used e.g. not to compare IDs that could change between test run
 191          * but only stable keys.
 192          * Optionally this also checks that specified keys are present in the actual item without
 193          * performing any checks on the related values.
 194          *
 195          * @param array $actualItems               array of actual items (associative arrays)
 196          * @param array $expectedItems             array of expected items (associative arrays),
 197          *                                         those items have less keys than actual items
 198          * @param array $keysUsedInValueComparison list of keys of the actual item that will be used
 199          *                                         in the comparison of values
 200          * @param array $requiredKeys              optional, list of keys that must be present in the
 201          *                                         actual items. Values of those keys are not checked.
 202          */
 203         private function assertArraySubsetsEqual(
 204                 array $actualItems,
 205                 array $expectedItems,
 206                 array $keysUsedInValueComparison,
 207                 array $requiredKeys = []
 208         ) {
 209                 $this->assertCount( count( $expectedItems ), $actualItems );
 210
 211                 // not checking values of all keys of the actual item, so removing unwanted keys from comparison
 212                 $actualItemsOnlyComparedValues = array_map(
 213                         function( array $item ) use ( $keysUsedInValueComparison ) {
 214                                 return array_intersect_key( $item, array_flip( $keysUsedInValueComparison ) );
 215                         },
 216                         $actualItems
 217                 );
 218
 219                 $this->assertEquals(
 220                         $expectedItems,
 221                         $actualItemsOnlyComparedValues
 222                 );
 223
 224                 // Check that each item in $actualItems contains all of keys specified in $requiredKeys
 225                 $actualItemsKeysOnly = array_map( 'array_keys', $actualItems );
 226                 foreach ( $actualItemsKeysOnly as $keysOfTheItem ) {
 227                         $this->assertEmpty( array_diff( $requiredKeys, $keysOfTheItem ) );
 228                 }
 229         }
 230
 231         private function getTitleFormatter() {
 232                 return new MediaWikiTitleCodec(
 233                         Language::factory( 'en' ),
 234                         MediaWikiServices::getInstance()->getGenderCache()
 235                 );
 236         }
 237
 238         private function getPrefixedText( LinkTarget $target ) {
 239                 $formatter = $this->getTitleFormatter();
 240                 return $formatter->getPrefixedText( $target );
 241         }
 242
 243         private function cleanTestUsersWatchlist() {
 244                 $user = $this->getLoggedInTestUser();
 245                 $store = $this->getWatchedItemStore();
 246                 $items = $store->getWatchedItemsForUser( $user );
 247                 foreach ( $items as $item ) {
 248                         $store->removeWatch( $user, $item->getLinkTarget() );
 249                 }
 250         }
 251
 252         public function testListWatchlist_returnsWatchedItemsWithRCInfo() {
 253                 // Clean up after previous tests that might have added something to the watchlist of
 254                 // the user with the same user ID as user used here as the test user
 255                 $this->cleanTestUsersWatchlist();
 256
 257                 $user = $this->getLoggedInTestUser();
 258                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 259                 $this->doPageEdit(
 260                         $user,
 261                         $target,
 262                         'Some Content',
 263                         'Create the page'
 264                 );
 265                 $this->watchPages( $user, [ $target ] );
 266
 267                 $result = $this->doListWatchlistRequest();
 268
 269                 $this->assertArrayHasKey( 'query', $result[0] );
 270                 $this->assertArrayHasKey( 'watchlist', $result[0]['query'] );
 271
 272                 $this->assertArraySubsetsEqual(
 273                         $this->getItemsFromApiResponse( $result ),
 274                         [
 275                                 [
 276                                         'type' => 'new',
 277                                         'ns' => $target->getNamespace(),
 278                                         'title' => $this->getPrefixedText( $target ),
 279                                         'bot' => false,
 280                                         'new' => true,
 281                                         'minor' => false,
 282                                 ]
 283                         ],
 284                         [ 'type', 'ns', 'title', 'bot', 'new', 'minor' ],
 285                         [ 'pageid', 'revid', 'old_revid' ]
 286                 );
 287         }
 288
 289         public function testIdsPropParameter() {
 290                 $user = $this->getLoggedInTestUser();
 291                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 292                 $this->doPageEdit(
 293                         $user,
 294                         $target,
 295                         'Some Content',
 296                         'Create the page'
 297                 );
 298                 $this->watchPages( $user, [ $target ] );
 299
 300                 $result = $this->doListWatchlistRequest( [ 'wlprop' => 'ids', ] );
 301                 $items = $this->getItemsFromApiResponse( $result );
 302
 303                 $this->assertCount( 1, $items );
 304                 $this->assertArrayHasKey( 'pageid', $items[0] );
 305                 $this->assertArrayHasKey( 'revid', $items[0] );
 306                 $this->assertArrayHasKey( 'old_revid', $items[0] );
 307                 $this->assertEquals( 'new', $items[0]['type'] );
 308         }
 309
 310         public function testTitlePropParameter() {
 311                 $user = $this->getLoggedInTestUser();
 312                 $subjectTarget = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 313                 $talkTarget = new TitleValue( 1, 'ApiQueryWatchlistIntegrationTestPage' );
 314                 $this->doPageEdits(
 315                         $user,
 316                         [
 317                                 [
 318                                         'target' => $subjectTarget,
 319                                         'content' => 'Some Content',
 320                                         'summary' => 'Create the page',
 321                                 ],
 322                                 [
 323                                         'target' => $talkTarget,
 324                                         'content' => 'Some Talk Page Content',
 325                                         'summary' => 'Create Talk page',
 326                                 ],
 327                         ]
 328                 );
 329                 $this->watchPages( $user, [ $subjectTarget, $talkTarget ] );
 330
 331                 $result = $this->doListWatchlistRequest( [ 'wlprop' => 'title', ] );
 332
 333                 $this->assertEquals(
 334                         [
 335                                 [
 336                                         'type' => 'new',
 337                                         'ns' => $talkTarget->getNamespace(),
 338                                         'title' => $this->getPrefixedText( $talkTarget ),
 339                                 ],
 340                                 [
 341                                         'type' => 'new',
 342                                         'ns' => $subjectTarget->getNamespace(),
 343                                         'title' => $this->getPrefixedText( $subjectTarget ),
 344                                 ],
 345                         ],
 346                         $this->getItemsFromApiResponse( $result )
 347                 );
 348         }
 349
 350         public function testFlagsPropParameter() {
 351                 $user = $this->getLoggedInTestUser();
 352                 $normalEditTarget = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 353                 $minorEditTarget = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPageM' );
 354                 $botEditTarget = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPageB' );
 355                 $this->doPageEdits(
 356                         $user,
 357                         [
 358                                 [
 359                                         'target' => $normalEditTarget,
 360                                         'content' => 'Some Content',
 361                                         'summary' => 'Create the page',
 362                                 ],
 363                                 [
 364                                         'target' => $minorEditTarget,
 365                                         'content' => 'Some Content',
 366                                         'summary' => 'Create the page',
 367                                 ],
 368                                 [
 369                                         'target' => $minorEditTarget,
 370                                         'content' => 'Slightly Better Content',
 371                                         'summary' => 'Change content',
 372                                         'minorEdit' => true,
 373                                 ],
 374                                 [
 375                                         'target' => $botEditTarget,
 376                                         'content' => 'Some Content',
 377                                         'summary' => 'Create the page with a bot',
 378                                         'botEdit' => true,
 379                                 ],
 380                         ]
 381                 );
 382                 $this->watchPages( $user, [ $normalEditTarget, $minorEditTarget, $botEditTarget ] );
 383
 384                 $result = $this->doListWatchlistRequest( [ 'wlprop' => 'flags', ] );
 385
 386                 $this->assertEquals(
 387                         [
 388                                 [
 389                                         'type' => 'new',
 390                                         'new' => true,
 391                                         'minor' => false,
 392                                         'bot' => true,
 393                                 ],
 394                                 [
 395                                         'type' => 'edit',
 396                                         'new' => false,
 397                                         'minor' => true,
 398                                         'bot' => false,
 399                                 ],
 400                                 [
 401                                         'type' => 'new',
 402                                         'new' => true,
 403                                         'minor' => false,
 404                                         'bot' => false,
 405                                 ],
 406                         ],
 407                         $this->getItemsFromApiResponse( $result )
 408                 );
 409         }
 410
 411         public function testUserPropParameter() {
 412                 $user = $this->getLoggedInTestUser();
 413                 $userEditTarget = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 414                 $anonEditTarget = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPageA' );
 415                 $this->doPageEdit(
 416                         $user,
 417                         $userEditTarget,
 418                         'Some Content',
 419                         'Create the page'
 420                 );
 421                 $this->doAnonPageEdit(
 422                         $anonEditTarget,
 423                         'Some Content',
 424                         'Create the page'
 425                 );
 426                 $this->watchPages( $user, [ $userEditTarget, $anonEditTarget ] );
 427
 428                 $result = $this->doListWatchlistRequest( [ 'wlprop' => 'user', ] );
 429
 430                 $this->assertEquals(
 431                         [
 432                                 [
 433                                         'type' => 'new',
 434                                         'anon' => true,
 435                                         'user' => User::newFromId( 0 )->getName(),
 436                                 ],
 437                                 [
 438                                         'type' => 'new',
 439                                         'user' => $user->getName(),
 440                                 ],
 441                         ],
 442                         $this->getItemsFromApiResponse( $result )
 443                 );
 444         }
 445
 446         public function testUserIdPropParameter() {
 447                 $user = $this->getLoggedInTestUser();
 448                 $userEditTarget = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 449                 $anonEditTarget = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPageA' );
 450                 $this->doPageEdit(
 451                         $user,
 452                         $userEditTarget,
 453                         'Some Content',
 454                         'Create the page'
 455                 );
 456                 $this->doAnonPageEdit(
 457                         $anonEditTarget,
 458                         'Some Content',
 459                         'Create the page'
 460                 );
 461                 $this->watchPages( $user, [ $userEditTarget, $anonEditTarget ] );
 462
 463                 $result = $this->doListWatchlistRequest( [ 'wlprop' => 'userid', ] );
 464
 465                 $this->assertEquals(
 466                         [
 467                                 [
 468                                         'type' => 'new',
 469                                         'anon' => true,
 470                                         'user' => 0,
 471                                         'userid' => 0,
 472                                 ],
 473                                 [
 474                                         'type' => 'new',
 475                                         'user' => $user->getId(),
 476                                         'userid' => $user->getId(),
 477                                 ],
 478                         ],
 479                         $this->getItemsFromApiResponse( $result )
 480                 );
 481         }
 482
 483         public function testCommentPropParameter() {
 484                 $user = $this->getLoggedInTestUser();
 485                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 486                 $this->doPageEdit(
 487                         $user,
 488                         $target,
 489                         'Some Content',
 490                         'Create the <b>page</b>'
 491                 );
 492                 $this->watchPages( $user, [ $target ] );
 493
 494                 $result = $this->doListWatchlistRequest( [ 'wlprop' => 'comment', ] );
 495
 496                 $this->assertEquals(
 497                         [
 498                                 [
 499                                         'type' => 'new',
 500                                         'comment' => 'Create the <b>page</b>',
 501                                 ],
 502                         ],
 503                         $this->getItemsFromApiResponse( $result )
 504                 );
 505         }
 506
 507         public function testParsedCommentPropParameter() {
 508                 $user = $this->getLoggedInTestUser();
 509                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 510                 $this->doPageEdit(
 511                         $user,
 512                         $target,
 513                         'Some Content',
 514                         'Create the <b>page</b>'
 515                 );
 516                 $this->watchPages( $user, [ $target ] );
 517
 518                 $result = $this->doListWatchlistRequest( [ 'wlprop' => 'parsedcomment', ] );
 519
 520                 $this->assertEquals(
 521                         [
 522                                 [
 523                                         'type' => 'new',
 524                                         'parsedcomment' => 'Create the &lt;b&gt;page&lt;/b&gt;',
 525                                 ],
 526                         ],
 527                         $this->getItemsFromApiResponse( $result )
 528                 );
 529         }
 530
 531         public function testTimestampPropParameter() {
 532                 $user = $this->getLoggedInTestUser();
 533                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 534                 $this->doPageEdit(
 535                         $user,
 536                         $target,
 537                         'Some Content',
 538                         'Create the page'
 539                 );
 540                 $this->watchPages( $user, [ $target ] );
 541
 542                 $result = $this->doListWatchlistRequest( [ 'wlprop' => 'timestamp', ] );
 543                 $items = $this->getItemsFromApiResponse( $result );
 544
 545                 $this->assertCount( 1, $items );
 546                 $this->assertArrayHasKey( 'timestamp', $items[0] );
 547                 $this->assertInternalType( 'string', $items[0]['timestamp'] );
 548         }
 549
 550         public function testSizesPropParameter() {
 551                 $user = $this->getLoggedInTestUser();
 552                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 553                 $this->doPageEdit(
 554                         $user,
 555                         $target,
 556                         'Some Content',
 557                         'Create the page'
 558                 );
 559                 $this->watchPages( $user, [ $target ] );
 560
 561                 $result = $this->doListWatchlistRequest( [ 'wlprop' => 'sizes', ] );
 562
 563                 $this->assertEquals(
 564                         [
 565                                 [
 566                                         'type' => 'new',
 567                                         'oldlen' => 0,
 568                                         'newlen' => 12,
 569                                 ],
 570                         ],
 571                         $this->getItemsFromApiResponse( $result )
 572                 );
 573         }
 574
 575         public function testNotificationTimestampPropParameter() {
 576                 $otherUser = $this->getNonLoggedInTestUser();
 577                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 578                 $this->doPageEdit(
 579                         $otherUser,
 580                         $target,
 581                         'Some Content',
 582                         'Create the page'
 583                 );
 584                 $store = $this->getWatchedItemStore();
 585                 $store->addWatch( $this->getLoggedInTestUser(), $target );
 586                 $store->updateNotificationTimestamp(
 587                         $otherUser,
 588                         $target,
 589                         '20151212010101'
 590                 );
 591
 592                 $result = $this->doListWatchlistRequest( [ 'wlprop' => 'notificationtimestamp', ] );
 593
 594                 $this->assertEquals(
 595                         [
 596                                 [
 597                                         'type' => 'new',
 598                                         'notificationtimestamp' => '2015-12-12T01:01:01Z',
 599                                 ],
 600                         ],
 601                         $this->getItemsFromApiResponse( $result )
 602                 );
 603         }
 604
 605         private function setupPatrolledSpecificFixtures( User $user ) {
 606                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 607
 608                 $this->doPatrolledPageEdit(
 609                         $user,
 610                         $target,
 611                         'Some Content',
 612                         'Create the page (this gets patrolled)',
 613                         $user
 614                 );
 615
 616                 $this->watchPages( $user, [ $target ] );
 617         }
 618
 619         public function testPatrolPropParameter() {
 620                 $testUser = static::getTestSysop();
 621                 $user = $testUser->getUser();
 622                 $this->setupPatrolledSpecificFixtures( $user );
 623
 624                 $result = $this->doListWatchlistRequest( [ 'wlprop' => 'patrol', ], $user );
 625
 626                 $this->assertEquals(
 627                         [
 628                                 [
 629                                         'type' => 'new',
 630                                         'patrolled' => true,
 631                                         'unpatrolled' => false,
 632                                 ]
 633                         ],
 634                         $this->getItemsFromApiResponse( $result )
 635                 );
 636         }
 637
 638         private function createPageAndDeleteIt( LinkTarget $target ) {
 639                 $this->doPageEdit(
 640                         $this->getLoggedInTestUser(),
 641                         $target,
 642                         'Some Content',
 643                         'Create the page that will be deleted'
 644                 );
 645                 $this->deletePage( $target, 'Important Reason' );
 646         }
 647
 648         public function testLoginfoPropParameter() {
 649                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 650                 $this->createPageAndDeleteIt( $target );
 651
 652                 $this->watchPages( $this->getLoggedInTestUser(), [ $target ] );
 653
 654                 $result = $this->doListWatchlistRequest( [ 'wlprop' => 'loginfo', ] );
 655
 656                 $this->assertArraySubsetsEqual(
 657                         $this->getItemsFromApiResponse( $result ),
 658                         [
 659                                 [
 660                                         'type' => 'log',
 661                                         'logtype' => 'delete',
 662                                         'logaction' => 'delete',
 663                                         'logparams' => [],
 664                                 ],
 665                         ],
 666                         [ 'type', 'logtype', 'logaction', 'logparams' ],
 667                         [ 'logid' ]
 668                 );
 669         }
 670
 671         public function testEmptyPropParameter() {
 672                 $user = $this->getLoggedInTestUser();
 673                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 674                 $this->doPageEdit(
 675                         $user,
 676                         $target,
 677                         'Some Content',
 678                         'Create the page'
 679                 );
 680                 $this->watchPages( $user, [ $target ] );
 681
 682                 $result = $this->doListWatchlistRequest( [ 'wlprop' => '', ] );
 683
 684                 $this->assertEquals(
 685                         [
 686                                 [
 687                                         'type' => 'new',
 688                                 ]
 689                         ],
 690                         $this->getItemsFromApiResponse( $result )
 691                 );
 692         }
 693
 694         public function testNamespaceParam() {
 695                 $user = $this->getLoggedInTestUser();
 696                 $subjectTarget = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 697                 $talkTarget = new TitleValue( 1, 'ApiQueryWatchlistIntegrationTestPage' );
 698                 $this->doPageEdits(
 699                         $user,
 700                         [
 701                                 [
 702                                         'target' => $subjectTarget,
 703                                         'content' => 'Some Content',
 704                                         'summary' => 'Create the page',
 705                                 ],
 706                                 [
 707                                         'target' => $talkTarget,
 708                                         'content' => 'Some Content',
 709                                         'summary' => 'Create the talk page',
 710                                 ],
 711                         ]
 712                 );
 713                 $this->watchPages( $user, [ $subjectTarget, $talkTarget ] );
 714
 715                 $result = $this->doListWatchlistRequest( [ 'wlnamespace' => '0', ] );
 716
 717                 $this->assertArraySubsetsEqual(
 718                         $this->getItemsFromApiResponse( $result ),
 719                         [
 720                                 [
 721                                         'ns' => 0,
 722                                         'title' => $this->getPrefixedText( $subjectTarget ),
 723                                 ],
 724                         ],
 725                         [ 'ns', 'title' ]
 726                 );
 727         }
 728
 729         public function testUserParam() {
 730                 $user = $this->getLoggedInTestUser();
 731                 $otherUser = $this->getNonLoggedInTestUser();
 732                 $subjectTarget = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 733                 $talkTarget = new TitleValue( 1, 'ApiQueryWatchlistIntegrationTestPage' );
 734                 $this->doPageEdit(
 735                         $user,
 736                         $subjectTarget,
 737                         'Some Content',
 738                         'Create the page'
 739                 );
 740                 $this->doPageEdit(
 741                         $otherUser,
 742                         $talkTarget,
 743                         'What is this page about?',
 744                         'Create the talk page'
 745                 );
 746                 $this->watchPages( $user, [ $subjectTarget, $talkTarget ] );
 747
 748                 $result = $this->doListWatchlistRequest( [
 749                         'wlprop' => 'user|title',
 750                         'wluser' => $otherUser->getName(),
 751                 ] );
 752
 753                 $this->assertEquals(
 754                         [
 755                                 [
 756                                         'type' => 'new',
 757                                         'ns' => $talkTarget->getNamespace(),
 758                                         'title' => $this->getPrefixedText( $talkTarget ),
 759                                         'user' => $otherUser->getName(),
 760                                 ],
 761                         ],
 762                         $this->getItemsFromApiResponse( $result )
 763                 );
 764         }
 765
 766         public function testExcludeUserParam() {
 767                 $user = $this->getLoggedInTestUser();
 768                 $otherUser = $this->getNonLoggedInTestUser();
 769                 $subjectTarget = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 770                 $talkTarget = new TitleValue( 1, 'ApiQueryWatchlistIntegrationTestPage' );
 771                 $this->doPageEdit(
 772                         $user,
 773                         $subjectTarget,
 774                         'Some Content',
 775                         'Create the page'
 776                 );
 777                 $this->doPageEdit(
 778                         $otherUser,
 779                         $talkTarget,
 780                         'What is this page about?',
 781                         'Create the talk page'
 782                 );
 783                 $this->watchPages( $user, [ $subjectTarget, $talkTarget ] );
 784
 785                 $result = $this->doListWatchlistRequest( [
 786                         'wlprop' => 'user|title',
 787                         'wlexcludeuser' => $otherUser->getName(),
 788                 ] );
 789
 790                 $this->assertEquals(
 791                         [
 792                                 [
 793                                         'type' => 'new',
 794                                         'ns' => $subjectTarget->getNamespace(),
 795                                         'title' => $this->getPrefixedText( $subjectTarget ),
 796                                         'user' => $user->getName(),
 797                                 ]
 798                         ],
 799                         $this->getItemsFromApiResponse( $result )
 800                 );
 801         }
 802
 803         public function testShowMinorParams() {
 804                 $user = $this->getLoggedInTestUser();
 805                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 806                 $this->doPageEdits(
 807                         $user,
 808                         [
 809                                 [
 810                                         'target' => $target,
 811                                         'content' => 'Some Content',
 812                                         'summary' => 'Create the page',
 813                                 ],
 814                                 [
 815                                         'target' => $target,
 816                                         'content' => 'Slightly Better Content',
 817                                         'summary' => 'Change content',
 818                                         'minorEdit' => true,
 819                                 ],
 820                         ]
 821                 );
 822                 $this->watchPages( $user, [ $target ] );
 823
 824                 $resultMinor = $this->doListWatchlistRequest( [ 'wlshow' => 'minor', 'wlprop' => 'flags' ] );
 825                 $resultNotMinor = $this->doListWatchlistRequest( [ 'wlshow' => '!minor', 'wlprop' => 'flags' ] );
 826
 827                 $this->assertArraySubsetsEqual(
 828                         $this->getItemsFromApiResponse( $resultMinor ),
 829                         [
 830                                 [ 'minor' => true, ]
 831                         ],
 832                         [ 'minor' ]
 833                 );
 834                 $this->assertEmpty( $this->getItemsFromApiResponse( $resultNotMinor ) );
 835         }
 836
 837         public function testShowBotParams() {
 838                 $user = $this->getLoggedInTestUser();
 839                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 840                 $this->doBotPageEdit(
 841                         $user,
 842                         $target,
 843                         'Some Content',
 844                         'Create the page'
 845                 );
 846                 $this->watchPages( $user, [ $target ] );
 847
 848                 $resultBot = $this->doListWatchlistRequest( [ 'wlshow' => 'bot' ] );
 849                 $resultNotBot = $this->doListWatchlistRequest( [ 'wlshow' => '!bot' ] );
 850
 851                 $this->assertArraySubsetsEqual(
 852                         $this->getItemsFromApiResponse( $resultBot ),
 853                         [
 854                                 [ 'bot' => true ],
 855                         ],
 856                         [ 'bot' ]
 857                 );
 858                 $this->assertEmpty( $this->getItemsFromApiResponse( $resultNotBot ) );
 859         }
 860
 861         public function testShowAnonParams() {
 862                 $user = $this->getLoggedInTestUser();
 863                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 864                 $this->doAnonPageEdit(
 865                         $target,
 866                         'Some Content',
 867                         'Create the page'
 868                 );
 869                 $this->watchPages( $user, [ $target ] );
 870
 871                 $resultAnon = $this->doListWatchlistRequest( [
 872                         'wlprop' => 'user',
 873                         'wlshow' => 'anon'
 874                 ] );
 875                 $resultNotAnon = $this->doListWatchlistRequest( [
 876                         'wlprop' => 'user',
 877                         'wlshow' => '!anon'
 878                 ] );
 879
 880                 $this->assertArraySubsetsEqual(
 881                         $this->getItemsFromApiResponse( $resultAnon ),
 882                         [
 883                                 [ 'anon' => true ],
 884                         ],
 885                         [ 'anon' ]
 886                 );
 887                 $this->assertEmpty( $this->getItemsFromApiResponse( $resultNotAnon ) );
 888         }
 889
 890         public function testShowUnreadParams() {
 891                 $user = $this->getLoggedInTestUser();
 892                 $otherUser = $this->getNonLoggedInTestUser();
 893                 $subjectTarget = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 894                 $talkTarget = new TitleValue( 1, 'ApiQueryWatchlistIntegrationTestPage' );
 895                 $this->doPageEdit(
 896                         $user,
 897                         $subjectTarget,
 898                         'Some Content',
 899                         'Create the page'
 900                 );
 901                 $this->doPageEdit(
 902                         $otherUser,
 903                         $talkTarget,
 904                         'Some Content',
 905                         'Create the talk page'
 906                 );
 907                 $store = $this->getWatchedItemStore();
 908                 $store->addWatchBatchForUser( $user, [ $subjectTarget, $talkTarget ] );
 909                 $store->updateNotificationTimestamp(
 910                         $otherUser,
 911                         $talkTarget,
 912                         '20151212010101'
 913                 );
 914
 915                 $resultUnread = $this->doListWatchlistRequest( [
 916                         'wlprop' => 'notificationtimestamp|title',
 917                         'wlshow' => 'unread'
 918                 ] );
 919                 $resultNotUnread = $this->doListWatchlistRequest( [
 920                         'wlprop' => 'notificationtimestamp|title',
 921                         'wlshow' => '!unread'
 922                 ] );
 923
 924                 $this->assertEquals(
 925                         [
 926                                 [
 927                                         'type' => 'new',
 928                                         'notificationtimestamp' => '2015-12-12T01:01:01Z',
 929                                         'ns' => $talkTarget->getNamespace(),
 930                                         'title' => $this->getPrefixedText( $talkTarget )
 931                                 ]
 932                         ],
 933                         $this->getItemsFromApiResponse( $resultUnread )
 934                 );
 935                 $this->assertEquals(
 936                         [
 937                                 [
 938                                         'type' => 'new',
 939                                         'notificationtimestamp' => '',
 940                                         'ns' => $subjectTarget->getNamespace(),
 941                                         'title' => $this->getPrefixedText( $subjectTarget )
 942                                 ]
 943                         ],
 944                         $this->getItemsFromApiResponse( $resultNotUnread )
 945                 );
 946         }
 947
 948         public function testShowPatrolledParams() {
 949                 $user = static::getTestSysop()->getUser();
 950                 $this->setupPatrolledSpecificFixtures( $user );
 951
 952                 $resultPatrolled = $this->doListWatchlistRequest( [
 953                         'wlprop' => 'patrol',
 954                         'wlshow' => 'patrolled'
 955                 ], $user );
 956                 $resultNotPatrolled = $this->doListWatchlistRequest( [
 957                         'wlprop' => 'patrol',
 958                         'wlshow' => '!patrolled'
 959                 ], $user );
 960
 961                 $this->assertEquals(
 962                         [
 963                                 [
 964                                         'type' => 'new',
 965                                         'patrolled' => true,
 966                                         'unpatrolled' => false,
 967                                 ]
 968                         ],
 969                         $this->getItemsFromApiResponse( $resultPatrolled )
 970                 );
 971                 $this->assertEmpty( $this->getItemsFromApiResponse( $resultNotPatrolled ) );
 972         }
 973
 974         public function testNewAndEditTypeParameters() {
 975                 $user = $this->getLoggedInTestUser();
 976                 $subjectTarget = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
 977                 $talkTarget = new TitleValue( 1, 'ApiQueryWatchlistIntegrationTestPage' );
 978                 $this->doPageEdits(
 979                         $user,
 980                         [
 981                                 [
 982                                         'target' => $subjectTarget,
 983                                         'content' => 'Some Content',
 984                                         'summary' => 'Create the page',
 985                                 ],
 986                                 [
 987                                         'target' => $subjectTarget,
 988                                         'content' => 'Some Other Content',
 989                                         'summary' => 'Change the content',
 990                                 ],
 991                                 [
 992                                         'target' => $talkTarget,
 993                                         'content' => 'Some Talk Page Content',
 994                                         'summary' => 'Create Talk page',
 995                                 ],
 996                         ]
 997                 );
 998                 $this->watchPages( $user, [ $subjectTarget, $talkTarget ] );
 999
1000                 $resultNew = $this->doListWatchlistRequest( [ 'wlprop' => 'title', 'wltype' => 'new' ] );
1001                 $resultEdit = $this->doListWatchlistRequest( [ 'wlprop' => 'title', 'wltype' => 'edit' ] );
1002
1003                 $this->assertEquals(
1004                         [
1005                                 [
1006                                         'type' => 'new',
1007                                         'ns' => $talkTarget->getNamespace(),
1008                                         'title' => $this->getPrefixedText( $talkTarget ),
1009                                 ],
1010                         ],
1011                         $this->getItemsFromApiResponse( $resultNew )
1012                 );
1013                 $this->assertEquals(
1014                         [
1015                                 [
1016                                         'type' => 'edit',
1017                                         'ns' => $subjectTarget->getNamespace(),
1018                                         'title' => $this->getPrefixedText( $subjectTarget ),
1019                                 ],
1020                         ],
1021                         $this->getItemsFromApiResponse( $resultEdit )
1022                 );
1023         }
1024
1025         public function testLogTypeParameters() {
1026                 $user = $this->getLoggedInTestUser();
1027                 $subjectTarget = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
1028                 $talkTarget = new TitleValue( 1, 'ApiQueryWatchlistIntegrationTestPage' );
1029                 $this->createPageAndDeleteIt( $subjectTarget );
1030                 $this->doPageEdit(
1031                         $user,
1032                         $talkTarget,
1033                         'Some Talk Page Content',
1034                         'Create Talk page'
1035                 );
1036                 $this->watchPages( $user, [ $subjectTarget, $talkTarget ] );
1037
1038                 $result = $this->doListWatchlistRequest( [ 'wlprop' => 'title', 'wltype' => 'log' ] );
1039
1040                 $this->assertEquals(
1041                         [
1042                                 [
1043                                         'type' => 'log',
1044                                         'ns' => $subjectTarget->getNamespace(),
1045                                         'title' => $this->getPrefixedText( $subjectTarget ),
1046                                 ],
1047                         ],
1048                         $this->getItemsFromApiResponse( $result )
1049                 );
1050         }
1051
1052         private function getExternalRC( LinkTarget $target ) {
1053                 $title = Title::newFromLinkTarget( $target );
1054
1055                 $rc = new RecentChange;
1056                 $rc->mTitle = $title;
1057                 $rc->mAttribs = [
1058                         'rc_timestamp' => wfTimestamp( TS_MW ),
1059                         'rc_namespace' => $title->getNamespace(),
1060                         'rc_title' => $title->getDBkey(),
1061                         'rc_type' => RC_EXTERNAL,
1062                         'rc_source' => 'foo',
1063                         'rc_minor' => 0,
1064                         'rc_cur_id' => $title->getArticleID(),
1065                         'rc_user' => 0,
1066                         'rc_user_text' => 'External User',
1067                         'rc_comment' => '',
1068                         'rc_this_oldid' => $title->getLatestRevID(),
1069                         'rc_last_oldid' => $title->getLatestRevID(),
1070                         'rc_bot' => 0,
1071                         'rc_ip' => '',
1072                         'rc_patrolled' => 0,
1073                         'rc_new' => 0,
1074                         'rc_old_len' => $title->getLength(),
1075                         'rc_new_len' => $title->getLength(),
1076                         'rc_deleted' => 0,
1077                         'rc_logid' => 0,
1078                         'rc_log_type' => null,
1079                         'rc_log_action' => '',
1080                         'rc_params' => '',
1081                 ];
1082                 $rc->mExtra = [
1083                         'prefixedDBkey' => $title->getPrefixedDBkey(),
1084                         'lastTimestamp' => 0,
1085                         'oldSize' => $title->getLength(),
1086                         'newSize' => $title->getLength(),
1087                         'pageStatus' => 'changed'
1088                 ];
1089
1090                 return $rc;
1091         }
1092
1093         public function testExternalTypeParameters() {
1094                 $user = $this->getLoggedInTestUser();
1095                 $subjectTarget = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
1096                 $talkTarget = new TitleValue( 1, 'ApiQueryWatchlistIntegrationTestPage' );
1097                 $this->doPageEdit(
1098                         $user,
1099                         $subjectTarget,
1100                         'Some Content',
1101                         'Create the page'
1102                 );
1103                 $this->doPageEdit(
1104                         $user,
1105                         $talkTarget,
1106                         'Some Talk Page Content',
1107                         'Create Talk page'
1108                 );
1109
1110                 $rc = $this->getExternalRC( $subjectTarget );
1111                 $rc->save();
1112
1113                 $this->watchPages( $user, [ $subjectTarget, $talkTarget ] );
1114
1115                 $result = $this->doListWatchlistRequest( [ 'wlprop' => 'title', 'wltype' => 'external' ] );
1116
1117                 $this->assertEquals(
1118                         [
1119                                 [
1120                                         'type' => 'external',
1121                                         'ns' => $subjectTarget->getNamespace(),
1122                                         'title' => $this->getPrefixedText( $subjectTarget ),
1123                                 ],
1124                         ],
1125                         $this->getItemsFromApiResponse( $result )
1126                 );
1127         }
1128
1129         public function testCategorizeTypeParameter() {
1130                 $user = $this->getLoggedInTestUser();
1131                 $subjectTarget = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
1132                 $categoryTarget = new TitleValue( NS_CATEGORY, 'ApiQueryWatchlistIntegrationTestCategory' );
1133                 $this->doPageEdits(
1134                         $user,
1135                         [
1136                                 [
1137                                         'target' => $categoryTarget,
1138                                         'content' => 'Some Content',
1139                                         'summary' => 'Create the category',
1140                                 ],
1141                                 [
1142                                         'target' => $subjectTarget,
1143                                         'content' => 'Some Content [[Category:ApiQueryWatchlistIntegrationTestCategory]]t',
1144                                         'summary' => 'Create the page and add it to the category',
1145                                 ],
1146                         ]
1147                 );
1148                 $title = Title::newFromLinkTarget( $subjectTarget );
1149                 $revision = Revision::newFromTitle( $title );
1150
1151                 $rc = RecentChange::newForCategorization(
1152                         $revision->getTimestamp(),
1153                         Title::newFromLinkTarget( $categoryTarget ),
1154                         $user,
1155                         $revision->getComment(),
1156                         $title,
1157                         0,
1158                         $revision->getId(),
1159                         null,
1160                         false
1161                 );
1162                 $rc->save();
1163
1164                 $this->watchPages( $user, [ $subjectTarget, $categoryTarget ] );
1165
1166                 $result = $this->doListWatchlistRequest( [ 'wlprop' => 'title', 'wltype' => 'categorize' ] );
1167
1168                 $this->assertEquals(
1169                         [
1170                                 [
1171                                         'type' => 'categorize',
1172                                         'ns' => $categoryTarget->getNamespace(),
1173                                         'title' => $this->getPrefixedText( $categoryTarget ),
1174                                 ],
1175                         ],
1176                         $this->getItemsFromApiResponse( $result )
1177                 );
1178         }
1179
1180         public function testLimitParam() {
1181                 $user = $this->getLoggedInTestUser();
1182                 $target1 = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
1183                 $target2 = new TitleValue( 1, 'ApiQueryWatchlistIntegrationTestPage' );
1184                 $target3 = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage2' );
1185                 $this->doPageEdits(
1186                         $user,
1187                         [
1188                                 [
1189                                         'target' => $target1,
1190                                         'content' => 'Some Content',
1191                                         'summary' => 'Create the page',
1192                                 ],
1193                                 [
1194                                         'target' => $target2,
1195                                         'content' => 'Some Talk Page Content',
1196                                         'summary' => 'Create Talk page',
1197                                 ],
1198                                 [
1199                                         'target' => $target3,
1200                                         'content' => 'Some Other Content',
1201                                         'summary' => 'Create the page',
1202                                 ],
1203                         ]
1204                 );
1205                 $this->watchPages( $user, [ $target1, $target2, $target3 ] );
1206
1207                 $resultWithoutLimit = $this->doListWatchlistRequest( [ 'wlprop' => 'title' ] );
1208                 $resultWithLimit = $this->doListWatchlistRequest( [ 'wllimit' => 2, 'wlprop' => 'title' ] );
1209
1210                 $this->assertEquals(
1211                         [
1212                                 [
1213                                         'type' => 'new',
1214                                         'ns' => $target3->getNamespace(),
1215                                         'title' => $this->getPrefixedText( $target3 )
1216                                 ],
1217                                 [
1218                                         'type' => 'new',
1219                                         'ns' => $target2->getNamespace(),
1220                                         'title' => $this->getPrefixedText( $target2 )
1221                                 ],
1222                                 [
1223                                         'type' => 'new',
1224                                         'ns' => $target1->getNamespace(),
1225                                         'title' => $this->getPrefixedText( $target1 )
1226                                 ],
1227                         ],
1228                         $this->getItemsFromApiResponse( $resultWithoutLimit )
1229                 );
1230                 $this->assertEquals(
1231                         [
1232                                 [
1233                                         'type' => 'new',
1234                                         'ns' => $target3->getNamespace(),
1235                                         'title' => $this->getPrefixedText( $target3 )
1236                                 ],
1237                                 [
1238                                         'type' => 'new',
1239                                         'ns' => $target2->getNamespace(),
1240                                         'title' => $this->getPrefixedText( $target2 )
1241                                 ],
1242                         ],
1243                         $this->getItemsFromApiResponse( $resultWithLimit )
1244                 );
1245                 $this->assertArrayHasKey( 'continue', $resultWithLimit[0] );
1246                 $this->assertArrayHasKey( 'wlcontinue', $resultWithLimit[0]['continue'] );
1247         }
1248
1249         public function testAllRevParam() {
1250                 $user = $this->getLoggedInTestUser();
1251                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
1252                 $this->doPageEdits(
1253                         $user,
1254                         [
1255                                 [
1256                                         'target' => $target,
1257                                         'content' => 'Some Content',
1258                                         'summary' => 'Create the page',
1259                                 ],
1260                                 [
1261                                         'target' => $target,
1262                                         'content' => 'Some Other Content',
1263                                         'summary' => 'Change the content',
1264                                 ],
1265                         ]
1266                 );
1267                 $this->watchPages( $user, [ $target ] );
1268
1269                 $resultAllRev = $this->doListWatchlistRequest( [ 'wlprop' => 'title', 'wlallrev' => '', ] );
1270                 $resultNoAllRev = $this->doListWatchlistRequest( [ 'wlprop' => 'title' ] );
1271
1272                 $this->assertEquals(
1273                         [
1274                                 [
1275                                         'type' => 'edit',
1276                                         'ns' => $target->getNamespace(),
1277                                         'title' => $this->getPrefixedText( $target ),
1278                                 ],
1279                         ],
1280                         $this->getItemsFromApiResponse( $resultNoAllRev )
1281                 );
1282                 $this->assertEquals(
1283                         [
1284                                 [
1285                                         'type' => 'edit',
1286                                         'ns' => $target->getNamespace(),
1287                                         'title' => $this->getPrefixedText( $target ),
1288                                 ],
1289                                 [
1290                                         'type' => 'new',
1291                                         'ns' => $target->getNamespace(),
1292                                         'title' => $this->getPrefixedText( $target ),
1293                                 ],
1294                         ],
1295                         $this->getItemsFromApiResponse( $resultAllRev )
1296                 );
1297         }
1298
1299         public function testDirParams() {
1300                 $user = $this->getLoggedInTestUser();
1301                 $subjectTarget = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
1302                 $talkTarget = new TitleValue( 1, 'ApiQueryWatchlistIntegrationTestPage' );
1303                 $this->doPageEdits(
1304                         $user,
1305                         [
1306                                 [
1307                                         'target' => $subjectTarget,
1308                                         'content' => 'Some Content',
1309                                         'summary' => 'Create the page',
1310                                 ],
1311                                 [
1312                                         'target' => $talkTarget,
1313                                         'content' => 'Some Talk Page Content',
1314                                         'summary' => 'Create Talk page',
1315                                 ],
1316                         ]
1317                 );
1318                 $this->watchPages( $user, [ $subjectTarget, $talkTarget ] );
1319
1320                 $resultDirOlder = $this->doListWatchlistRequest( [ 'wldir' => 'older', 'wlprop' => 'title' ] );
1321                 $resultDirNewer = $this->doListWatchlistRequest( [ 'wldir' => 'newer', 'wlprop' => 'title' ] );
1322
1323                 $this->assertEquals(
1324                         [
1325                                 [
1326                                         'type' => 'new',
1327                                         'ns' => $talkTarget->getNamespace(),
1328                                         'title' => $this->getPrefixedText( $talkTarget )
1329                                 ],
1330                                 [
1331                                         'type' => 'new',
1332                                         'ns' => $subjectTarget->getNamespace(),
1333                                         'title' => $this->getPrefixedText( $subjectTarget )
1334                                 ],
1335                         ],
1336                         $this->getItemsFromApiResponse( $resultDirOlder )
1337                 );
1338                 $this->assertEquals(
1339                         [
1340                                 [
1341                                         'type' => 'new',
1342                                         'ns' => $subjectTarget->getNamespace(),
1343                                         'title' => $this->getPrefixedText( $subjectTarget )
1344                                 ],
1345                                 [
1346                                         'type' => 'new',
1347                                         'ns' => $talkTarget->getNamespace(),
1348                                         'title' => $this->getPrefixedText( $talkTarget )
1349                                 ],
1350                         ],
1351                         $this->getItemsFromApiResponse( $resultDirNewer )
1352                 );
1353         }
1354
1355         public function testStartEndParams() {
1356                 $user = $this->getLoggedInTestUser();
1357                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
1358                 $this->doPageEdit(
1359                         $user,
1360                         $target,
1361                         'Some Content',
1362                         'Create the page'
1363                 );
1364                 $this->watchPages( $user, [ $target ] );
1365
1366                 $resultStart = $this->doListWatchlistRequest( [
1367                         'wlstart' => '20010115000000',
1368                         'wldir' => 'newer',
1369                         'wlprop' => 'title',
1370                 ] );
1371                 $resultEnd = $this->doListWatchlistRequest( [
1372                         'wlend' => '20010115000000',
1373                         'wldir' => 'newer',
1374                         'wlprop' => 'title',
1375                 ] );
1376
1377                 $this->assertEquals(
1378                         [
1379                                 [
1380                                         'type' => 'new',
1381                                         'ns' => $target->getNamespace(),
1382                                         'title' => $this->getPrefixedText( $target ),
1383                                 ]
1384                         ],
1385                         $this->getItemsFromApiResponse( $resultStart )
1386                 );
1387                 $this->assertEmpty( $this->getItemsFromApiResponse( $resultEnd ) );
1388         }
1389
1390         public function testContinueParam() {
1391                 $user = $this->getLoggedInTestUser();
1392                 $target1 = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
1393                 $target2 = new TitleValue( 1, 'ApiQueryWatchlistIntegrationTestPage' );
1394                 $target3 = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage2' );
1395                 $this->doPageEdits(
1396                         $user,
1397                         [
1398                                 [
1399                                         'target' => $target1,
1400                                         'content' => 'Some Content',
1401                                         'summary' => 'Create the page',
1402                                 ],
1403                                 [
1404                                         'target' => $target2,
1405                                         'content' => 'Some Talk Page Content',
1406                                         'summary' => 'Create Talk page',
1407                                 ],
1408                                 [
1409                                         'target' => $target3,
1410                                         'content' => 'Some Other Content',
1411                                         'summary' => 'Create the page',
1412                                 ],
1413                         ]
1414                 );
1415                 $this->watchPages( $user, [ $target1, $target2, $target3 ] );
1416
1417                 $firstResult = $this->doListWatchlistRequest( [ 'wllimit' => 2, 'wlprop' => 'title' ] );
1418                 $this->assertArrayHasKey( 'continue', $firstResult[0] );
1419                 $this->assertArrayHasKey( 'wlcontinue', $firstResult[0]['continue'] );
1420
1421                 $continuationParam = $firstResult[0]['continue']['wlcontinue'];
1422
1423                 $continuedResult = $this->doListWatchlistRequest(
1424                         [ 'wlcontinue' => $continuationParam, 'wlprop' => 'title' ]
1425                 );
1426
1427                 $this->assertEquals(
1428                         [
1429                                 [
1430                                         'type' => 'new',
1431                                         'ns' => $target3->getNamespace(),
1432                                         'title' => $this->getPrefixedText( $target3 ),
1433                                 ],
1434                                 [
1435                                         'type' => 'new',
1436                                         'ns' => $target2->getNamespace(),
1437                                         'title' => $this->getPrefixedText( $target2 ),
1438                                 ],
1439                         ],
1440                         $this->getItemsFromApiResponse( $firstResult )
1441                 );
1442                 $this->assertEquals(
1443                         [
1444                                 [
1445                                         'type' => 'new',
1446                                         'ns' => $target1->getNamespace(),
1447                                         'title' => $this->getPrefixedText( $target1 )
1448                                 ]
1449                         ],
1450                         $this->getItemsFromApiResponse( $continuedResult )
1451                 );
1452         }
1453
1454         public function testOwnerAndTokenParams() {
1455                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
1456                 $this->doPageEdit(
1457                         $this->getLoggedInTestUser(),
1458                         $target,
1459                         'Some Content',
1460                         'Create the page'
1461                 );
1462
1463                 $otherUser = $this->getNonLoggedInTestUser();
1464                 $otherUser->setOption( 'watchlisttoken', '1234567890' );
1465                 $otherUser->saveSettings();
1466
1467                 $this->watchPages( $otherUser, [ $target ] );
1468
1469                 $result = $this->doListWatchlistRequest( [
1470                         'wlowner' => $otherUser->getName(),
1471                         'wltoken' => '1234567890',
1472                         'wlprop' => 'title',
1473                 ] );
1474
1475                 $this->assertEquals(
1476                         [
1477                                 [
1478                                         'type' => 'new',
1479                                         'ns' => $target->getNamespace(),
1480                                         'title' => $this->getPrefixedText( $target )
1481                                 ]
1482                         ],
1483                         $this->getItemsFromApiResponse( $result )
1484                 );
1485         }
1486
1487         public function testOwnerAndTokenParams_wrongToken() {
1488                 $otherUser = $this->getNonLoggedInTestUser();
1489                 $otherUser->setOption( 'watchlisttoken', '1234567890' );
1490                 $otherUser->saveSettings();
1491
1492                 $this->setExpectedException( UsageException::class, 'Incorrect watchlist token provided' );
1493
1494                 $this->doListWatchlistRequest( [
1495                         'wlowner' => $otherUser->getName(),
1496                         'wltoken' => 'wrong-token',
1497                 ] );
1498         }
1499
1500         public function testOwnerAndTokenParams_noWatchlistTokenSet() {
1501                 $this->setExpectedException( UsageException::class, 'Incorrect watchlist token provided' );
1502
1503                 $this->doListWatchlistRequest( [
1504                         'wlowner' => $this->getNonLoggedInTestUser()->getName(),
1505                         'wltoken' => 'some-token',
1506                 ] );
1507         }
1508
1509         public function testGeneratorWatchlistPropInfo_returnsWatchedPages() {
1510                 $user = $this->getLoggedInTestUser();
1511                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
1512                 $this->doPageEdit(
1513                         $user,
1514                         $target,
1515                         'Some Content',
1516                         'Create the page'
1517                 );
1518                 $this->watchPages( $user, [ $target ] );
1519
1520                 $result = $this->doGeneratorWatchlistRequest( [ 'prop' => 'info' ] );
1521
1522                 $this->assertArrayHasKey( 'query', $result[0] );
1523                 $this->assertArrayHasKey( 'pages', $result[0]['query'] );
1524
1525                 // $result[0]['query']['pages'] uses page ids as keys. Page ids don't matter here, so drop them
1526                 $pages = array_values( $result[0]['query']['pages'] );
1527
1528                 $this->assertArraySubsetsEqual(
1529                         $pages,
1530                         [
1531                                 [
1532                                         'ns' => $target->getNamespace(),
1533                                         'title' => $this->getPrefixedText( $target ),
1534                                         'new' => true,
1535                                 ]
1536                         ],
1537                         [ 'ns', 'title', 'new' ]
1538                 );
1539         }
1540
1541         public function testGeneratorWatchlistPropRevisions_returnsWatchedItemsRevisions() {
1542                 $user = $this->getLoggedInTestUser();
1543                 $target = new TitleValue( 0, 'ApiQueryWatchlistIntegrationTestPage' );
1544                 $this->doPageEdits(
1545                         $user,
1546                         [
1547                                 [
1548                                         'target' => $target,
1549                                         'content' => 'Some Content',
1550                                         'summary' => 'Create the page',
1551                                 ],
1552                                 [
1553                                         'target' => $target,
1554                                         'content' => 'Some Other Content',
1555                                         'summary' => 'Change the content',
1556                                 ],
1557                         ]
1558                 );
1559                 $this->watchPages( $user, [ $target ] );
1560
1561                 $result = $this->doGeneratorWatchlistRequest( [ 'prop' => 'revisions', 'gwlallrev' => '' ] );
1562
1563                 $this->assertArrayHasKey( 'query', $result[0] );
1564                 $this->assertArrayHasKey( 'pages', $result[0]['query'] );
1565
1566                 // $result[0]['query']['pages'] uses page ids as keys. Page ids don't matter here, so drop them
1567                 $pages = array_values( $result[0]['query']['pages'] );
1568
1569                 $this->assertCount( 1, $pages );
1570                 $this->assertEquals( 0, $pages[0]['ns'] );
1571                 $this->assertEquals( $this->getPrefixedText( $target ), $pages[0]['title'] );
1572                 $this->assertArraySubsetsEqual(
1573                         $pages[0]['revisions'],
1574                         [
1575                                 [
1576                                         'comment' => 'Create the page',
1577                                         'user' => $user->getName(),
1578                                         'minor' => false,
1579                                 ],
1580                                 [
1581                                         'comment' => 'Change the content',
1582                                         'user' => $user->getName(),
1583                                         'minor' => false,
1584                                 ],
1585                         ],
1586                         [ 'comment', 'user', 'minor' ]
1587                 );
1588         }
1589
1590 }