tests/phpunit/includes/deferred/LinksUpdateTest.php

   1 <?php
   2
   3 /**
   4  * @group LinksUpdate
   5  * @group Database
   6  * ^--- make sure temporary tables are used.
   7  */
   8 class LinksUpdateTest extends MediaWikiLangTestCase {
   9         protected static $testingPageId;
  10
  11         function __construct( $name = null, array $data = [], $dataName = '' ) {
  12                 parent::__construct( $name, $data, $dataName );
  13
  14                 $this->tablesUsed = array_merge( $this->tablesUsed,
  15                         [
  16                                 'interwiki',
  17                                 'page_props',
  18                                 'pagelinks',
  19                                 'categorylinks',
  20                                 'langlinks',
  21                                 'externallinks',
  22                                 'imagelinks',
  23                                 'templatelinks',
  24                                 'iwlinks',
  25                                 'recentchanges',
  26                         ]
  27                 );
  28         }
  29
  30         protected function setUp() {
  31                 parent::setUp();
  32                 $dbw = wfGetDB( DB_MASTER );
  33                 $dbw->replace(
  34                         'interwiki',
  35                         [ 'iw_prefix' ],
  36                         [
  37                                 'iw_prefix' => 'linksupdatetest',
  38                                 'iw_url' => 'http://testing.com/wiki/$1',
  39                                 'iw_api' => 'http://testing.com/w/api.php',
  40                                 'iw_local' => 0,
  41                                 'iw_trans' => 0,
  42                                 'iw_wikiid' => 'linksupdatetest',
  43                         ]
  44                 );
  45                 $this->setMwGlobals( 'wgRCWatchCategoryMembership', true );
  46         }
  47
  48         public function addDBDataOnce() {
  49                 $res = $this->insertPage( 'Testing' );
  50                 self::$testingPageId = $res['id'];
  51                 $this->insertPage( 'Some_other_page' );
  52                 $this->insertPage( 'Template:TestingTemplate' );
  53         }
  54
  55         protected function makeTitleAndParserOutput( $name, $id ) {
  56                 $t = Title::newFromText( $name );
  57                 $t->mArticleID = $id; # XXX: this is fugly
  58
  59                 $po = new ParserOutput();
  60                 $po->setTitleText( $t->getPrefixedText() );
  61
  62                 return [ $t, $po ];
  63         }
  64
  65         /**
  66          * @covers ParserOutput::addLink
  67          */
  68         public function testUpdate_pagelinks() {
  69                 /** @var Title $t */
  70                 /** @var ParserOutput $po */
  71                 list( $t, $po ) = $this->makeTitleAndParserOutput( "Testing", self::$testingPageId );
  72
  73                 $po->addLink( Title::newFromText( "Foo" ) );
  74                 $po->addLink( Title::newFromText( "Special:Foo" ) ); // special namespace should be ignored
  75                 $po->addLink( Title::newFromText( "linksupdatetest:Foo" ) ); // interwiki link should be ignored
  76                 $po->addLink( Title::newFromText( "#Foo" ) ); // hash link should be ignored
  77
  78                 $update = $this->assertLinksUpdate(
  79                         $t,
  80                         $po,
  81                         'pagelinks',
  82                         'pl_namespace,
  83                         pl_title',
  84                         'pl_from = ' . self::$testingPageId,
  85                         [ [ NS_MAIN, 'Foo' ] ]
  86                 );
  87                 $this->assertArrayEquals( [
  88                         Title::makeTitle( NS_MAIN, 'Foo' ),  // newFromText doesn't yield the same internal state....
  89                 ], $update->getAddedLinks() );
  90
  91                 $po = new ParserOutput();
  92                 $po->setTitleText( $t->getPrefixedText() );
  93
  94                 $po->addLink( Title::newFromText( "Bar" ) );
  95                 $po->addLink( Title::newFromText( "Talk:Bar" ) );
  96
  97                 $update = $this->assertLinksUpdate(
  98                         $t,
  99                         $po,
 100                         'pagelinks',
 101                         'pl_namespace,
 102                         pl_title',
 103                         'pl_from = ' . self::$testingPageId,
 104                         [
 105                                 [ NS_MAIN, 'Bar' ],
 106                                 [ NS_TALK, 'Bar' ],
 107                         ]
 108                 );
 109                 $this->assertArrayEquals( [
 110                         Title::makeTitle( NS_MAIN, 'Bar' ),
 111                         Title::makeTitle( NS_TALK, 'Bar' ),
 112                 ], $update->getAddedLinks() );
 113                 $this->assertArrayEquals( [
 114                         Title::makeTitle( NS_MAIN, 'Foo' ),
 115                 ], $update->getRemovedLinks() );
 116         }
 117
 118         /**
 119          * @covers ParserOutput::addExternalLink
 120          */
 121         public function testUpdate_externallinks() {
 122                 /** @var ParserOutput $po */
 123                 list( $t, $po ) = $this->makeTitleAndParserOutput( "Testing", self::$testingPageId );
 124
 125                 $po->addExternalLink( "http://testing.com/wiki/Foo" );
 126
 127                 $this->assertLinksUpdate(
 128                         $t,
 129                         $po,
 130                         'externallinks',
 131                         'el_to, el_index',
 132                         'el_from = ' . self::$testingPageId,
 133                         [
 134                                 [ 'http://testing.com/wiki/Foo', 'http://com.testing./wiki/Foo' ],
 135                         ]
 136                 );
 137         }
 138
 139         /**
 140          * @covers ParserOutput::addCategory
 141          */
 142         public function testUpdate_categorylinks() {
 143                 /** @var ParserOutput $po */
 144                 $this->setMwGlobals( 'wgCategoryCollation', 'uppercase' );
 145
 146                 list( $t, $po ) = $this->makeTitleAndParserOutput( "Testing", self::$testingPageId );
 147
 148                 $po->addCategory( "Foo", "FOO" );
 149
 150                 $this->assertLinksUpdate(
 151                         $t,
 152                         $po,
 153                         'categorylinks',
 154                         'cl_to, cl_sortkey',
 155                         'cl_from = ' . self::$testingPageId,
 156                         [ [ 'Foo', "FOO\nTESTING" ] ]
 157                 );
 158         }
 159
 160         public function testOnAddingAndRemovingCategory_recentChangesRowIsAdded() {
 161                 $this->setMwGlobals( 'wgCategoryCollation', 'uppercase' );
 162
 163                 $title = Title::newFromText( 'Testing' );
 164                 $wikiPage = new WikiPage( $title );
 165                 $wikiPage->doEditContent( new WikitextContent( '[[Category:Foo]]' ), 'added category' );
 166                 $this->runAllRelatedJobs();
 167
 168                 $this->assertRecentChangeByCategorization(
 169                         $title,
 170                         $wikiPage->getParserOutput( ParserOptions::newCanonical() ),
 171                         Title::newFromText( 'Category:Foo' ),
 172                         [ [ 'Foo', '[[:Testing]] added to category' ] ]
 173                 );
 174
 175                 $wikiPage->doEditContent( new WikitextContent( '[[Category:Bar]]' ), 'replaced category' );
 176                 $this->runAllRelatedJobs();
 177
 178                 $this->assertRecentChangeByCategorization(
 179                         $title,
 180                         $wikiPage->getParserOutput( ParserOptions::newCanonical() ),
 181                         Title::newFromText( 'Category:Foo' ),
 182                         [
 183                                 [ 'Foo', '[[:Testing]] added to category' ],
 184                                 [ 'Foo', '[[:Testing]] removed from category' ],
 185                         ]
 186                 );
 187
 188                 $this->assertRecentChangeByCategorization(
 189                         $title,
 190                         $wikiPage->getParserOutput( ParserOptions::newCanonical() ),
 191                         Title::newFromText( 'Category:Bar' ),
 192                         [
 193                                 [ 'Bar', '[[:Testing]] added to category' ],
 194                         ]
 195                 );
 196         }
 197
 198         public function testOnAddingAndRemovingCategoryToTemplates_embeddingPagesAreIgnored() {
 199                 $this->setMwGlobals( 'wgCategoryCollation', 'uppercase' );
 200
 201                 $templateTitle = Title::newFromText( 'Template:TestingTemplate' );
 202                 $templatePage = new WikiPage( $templateTitle );
 203
 204                 $wikiPage = new WikiPage( Title::newFromText( 'Testing' ) );
 205                 $wikiPage->doEditContent( new WikitextContent( '{{TestingTemplate}}' ), 'added template' );
 206                 $this->runAllRelatedJobs();
 207
 208                 $otherWikiPage = new WikiPage( Title::newFromText( 'Some_other_page' ) );
 209                 $otherWikiPage->doEditContent( new WikitextContent( '{{TestingTemplate}}' ), 'added template' );
 210                 $this->runAllRelatedJobs();
 211
 212                 $this->assertRecentChangeByCategorization(
 213                         $templateTitle,
 214                         $templatePage->getParserOutput( ParserOptions::newCanonical() ),
 215                         Title::newFromText( 'Baz' ),
 216                         []
 217                 );
 218
 219                 $templatePage->doEditContent( new WikitextContent( '[[Category:Baz]]' ), 'added category' );
 220                 $this->runAllRelatedJobs();
 221
 222                 $this->assertRecentChangeByCategorization(
 223                         $templateTitle,
 224                         $templatePage->getParserOutput( ParserOptions::newCanonical() ),
 225                         Title::newFromText( 'Baz' ),
 226                         [ [
 227                                 'Baz',
 228                                 '[[:Template:TestingTemplate]] added to category, ' .
 229                                 '[[Special:WhatLinksHere/Template:TestingTemplate|this page is included within other pages]]'
 230                         ] ]
 231                 );
 232         }
 233
 234         /**
 235          * @covers ParserOutput::addInterwikiLink
 236          */
 237         public function testUpdate_iwlinks() {
 238                 /** @var ParserOutput $po */
 239                 list( $t, $po ) = $this->makeTitleAndParserOutput( "Testing", self::$testingPageId );
 240
 241                 $target = Title::makeTitleSafe( NS_MAIN, "Foo", '', 'linksupdatetest' );
 242                 $po->addInterwikiLink( $target );
 243
 244                 $this->assertLinksUpdate(
 245                         $t,
 246                         $po,
 247                         'iwlinks',
 248                         'iwl_prefix, iwl_title',
 249                         'iwl_from = ' . self::$testingPageId,
 250                         [ [ 'linksupdatetest', 'Foo' ] ]
 251                 );
 252         }
 253
 254         /**
 255          * @covers ParserOutput::addTemplate
 256          */
 257         public function testUpdate_templatelinks() {
 258                 /** @var ParserOutput $po */
 259                 list( $t, $po ) = $this->makeTitleAndParserOutput( "Testing", self::$testingPageId );
 260
 261                 $po->addTemplate( Title::newFromText( "Template:Foo" ), 23, 42 );
 262
 263                 $this->assertLinksUpdate(
 264                         $t,
 265                         $po,
 266                         'templatelinks',
 267                         'tl_namespace,
 268                         tl_title',
 269                         'tl_from = ' . self::$testingPageId,
 270                         [ [ NS_TEMPLATE, 'Foo' ] ]
 271                 );
 272         }
 273
 274         /**
 275          * @covers ParserOutput::addImage
 276          */
 277         public function testUpdate_imagelinks() {
 278                 /** @var ParserOutput $po */
 279                 list( $t, $po ) = $this->makeTitleAndParserOutput( "Testing", self::$testingPageId );
 280
 281                 $po->addImage( "Foo.png" );
 282
 283                 $this->assertLinksUpdate(
 284                         $t,
 285                         $po,
 286                         'imagelinks',
 287                         'il_to',
 288                         'il_from = ' . self::$testingPageId,
 289                         [ [ 'Foo.png' ] ]
 290                 );
 291         }
 292
 293         /**
 294          * @covers ParserOutput::addLanguageLink
 295          */
 296         public function testUpdate_langlinks() {
 297                 $this->setMwGlobals( [
 298                         'wgCapitalLinks' => true,
 299                 ] );
 300
 301                 /** @var ParserOutput $po */
 302                 list( $t, $po ) = $this->makeTitleAndParserOutput( "Testing", self::$testingPageId );
 303
 304                 $po->addLanguageLink( Title::newFromText( "en:Foo" )->getFullText() );
 305
 306                 $this->assertLinksUpdate(
 307                         $t,
 308                         $po,
 309                         'langlinks',
 310                         'll_lang, ll_title',
 311                         'll_from = ' . self::$testingPageId,
 312                         [ [ 'En', 'Foo' ] ]
 313                 );
 314         }
 315
 316         /**
 317          * @covers ParserOutput::setProperty
 318          */
 319         public function testUpdate_page_props() {
 320                 global $wgPagePropsHaveSortkey;
 321
 322                 /** @var ParserOutput $po */
 323                 list( $t, $po ) = $this->makeTitleAndParserOutput( "Testing", self::$testingPageId );
 324
 325                 $fields = [ 'pp_propname', 'pp_value' ];
 326                 $expected = [];
 327
 328                 $po->setProperty( "bool", true );
 329                 $expected[] = [ "bool", true ];
 330
 331                 $po->setProperty( "float", 4.0 + 1.0 / 4.0 );
 332                 $expected[] = [ "float", 4.0 + 1.0 / 4.0 ];
 333
 334                 $po->setProperty( "int", -7 );
 335                 $expected[] = [ "int", -7 ];
 336
 337                 $po->setProperty( "string", "33 bar" );
 338                 $expected[] = [ "string", "33 bar" ];
 339
 340                 // compute expected sortkey values
 341                 if ( $wgPagePropsHaveSortkey ) {
 342                         $fields[] = 'pp_sortkey';
 343
 344                         foreach ( $expected as &$row ) {
 345                                 $value = $row[1];
 346
 347                                 if ( is_int( $value ) || is_float( $value ) || is_bool( $value ) ) {
 348                                         $row[] = floatval( $value );
 349                                 } else {
 350                                         $row[] = null;
 351                                 }
 352                         }
 353                 }
 354
 355                 $this->assertLinksUpdate(
 356                         $t, $po, 'page_props', $fields, 'pp_page = ' . self::$testingPageId, $expected );
 357         }
 358
 359         public function testUpdate_page_props_without_sortkey() {
 360                 $this->setMwGlobals( 'wgPagePropsHaveSortkey', false );
 361
 362                 $this->testUpdate_page_props();
 363         }
 364
 365         // @todo test recursive, too!
 366
 367         protected function assertLinksUpdate( Title $title, ParserOutput $parserOutput,
 368                 $table, $fields, $condition, array $expectedRows
 369         ) {
 370                 $update = new LinksUpdate( $title, $parserOutput );
 371
 372                 $update->doUpdate();
 373
 374                 $this->assertSelect( $table, $fields, $condition, $expectedRows );
 375                 return $update;
 376         }
 377
 378         protected function assertRecentChangeByCategorization(
 379                 Title $pageTitle, ParserOutput $parserOutput, Title $categoryTitle, $expectedRows
 380         ) {
 381                 global $wgCommentTableSchemaMigrationStage;
 382
 383                 if ( $wgCommentTableSchemaMigrationStage <= MIGRATION_WRITE_BOTH ) {
 384                         $this->assertSelect(
 385                                 'recentchanges',
 386                                 'rc_title, rc_comment',
 387                                 [
 388                                         'rc_type' => RC_CATEGORIZE,
 389                                         'rc_namespace' => NS_CATEGORY,
 390                                         'rc_title' => $categoryTitle->getDBkey()
 391                                 ],
 392                                 $expectedRows
 393                         );
 394                 }
 395                 if ( $wgCommentTableSchemaMigrationStage >= MIGRATION_WRITE_BOTH ) {
 396                         $this->assertSelect(
 397                                 [ 'recentchanges', 'comment' ],
 398                                 'rc_title, comment_text',
 399                                 [
 400                                         'rc_type' => RC_CATEGORIZE,
 401                                         'rc_namespace' => NS_CATEGORY,
 402                                         'rc_title' => $categoryTitle->getDBkey(),
 403                                         'comment_id = rc_comment_id',
 404                                 ],
 405                                 $expectedRows
 406                         );
 407                 }
 408         }
 409
 410         private function runAllRelatedJobs() {
 411                 $queueGroup = JobQueueGroup::singleton();
 412                 while ( $job = $queueGroup->pop( 'refreshLinksPrioritized' ) ) {
 413                         $job->run();
 414                         $queueGroup->ack( $job );
 415                 }
 416                 while ( $job = $queueGroup->pop( 'categoryMembershipChange' ) ) {
 417                         $job->run();
 418                         $queueGroup->ack( $job );
 419                 }
 420         }
 421 }