tests/phpunit/includes/deferred/LinksUpdateTest.php

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