tests/phpunit/includes/logging/LogFormatterTest.php

   1 <?php
   2
   3 /**
   4  * @group Database
   5  */
   6 class LogFormatterTest extends MediaWikiLangTestCase {
   7
   8         /**
   9          * @var User
  10          */
  11         protected $user;
  12
  13         /**
  14          * @var Title
  15          */
  16         protected $title;
  17
  18         /**
  19          * @var RequestContext
  20          */
  21         protected $context;
  22
  23         /**
  24          * @var Title
  25          */
  26         protected $target;
  27
  28         /**
  29          * @var string
  30          */
  31         protected $user_comment;
  32
  33         protected function setUp() {
  34                 parent::setUp();
  35
  36                 global $wgLang;
  37
  38                 $this->setMwGlobals( array(
  39                         'wgLogTypes' => array( 'phpunit' ),
  40                         'wgLogActionsHandlers' => array( 'phpunit/test' => 'LogFormatter',
  41                                 'phpunit/param' => 'LogFormatter' ),
  42                         'wgUser' => User::newFromName( 'Testuser' ),
  43                         'wgExtensionMessagesFiles' => array( 'LogTests' => __DIR__ . '/LogTests.i18n.php' ),
  44                 ) );
  45
  46                 Language::getLocalisationCache()->recache( $wgLang->getCode() );
  47
  48                 $this->user = User::newFromName( 'Testuser' );
  49                 $this->title = Title::newFromText( 'SomeTitle' );
  50                 $this->target = Title::newFromText( 'TestTarget' );
  51
  52                 $this->context = new RequestContext();
  53                 $this->context->setUser( $this->user );
  54                 $this->context->setTitle( $this->title );
  55                 $this->context->setLanguage( $wgLang );
  56
  57                 $this->user_comment = '<User comment about action>';
  58         }
  59
  60         protected function tearDown() {
  61                 parent::tearDown();
  62
  63                 global $wgLang;
  64                 Language::getLocalisationCache()->recache( $wgLang->getCode() );
  65         }
  66
  67         public function newLogEntry( $action, $params ) {
  68                 $logEntry = new ManualLogEntry( 'phpunit', $action );
  69                 $logEntry->setPerformer( $this->user );
  70                 $logEntry->setTarget( $this->title );
  71                 $logEntry->setComment( 'A very good reason' );
  72
  73                 $logEntry->setParameters( $params );
  74
  75                 return $logEntry;
  76         }
  77
  78         /**
  79          * @covers LogFormatter::newFromEntry
  80          */
  81         public function testNormalLogParams() {
  82                 $entry = $this->newLogEntry( 'test', array() );
  83                 $formatter = LogFormatter::newFromEntry( $entry );
  84                 $formatter->setContext( $this->context );
  85
  86                 $formatter->setShowUserToolLinks( false );
  87                 $paramsWithoutTools = $formatter->getMessageParametersForTesting();
  88                 unset( $formatter->parsedParameters );
  89
  90                 $formatter->setShowUserToolLinks( true );
  91                 $paramsWithTools = $formatter->getMessageParametersForTesting();
  92
  93                 $userLink = Linker::userLink(
  94                         $this->user->getId(),
  95                         $this->user->getName()
  96                 );
  97
  98                 $userTools = Linker::userToolLinksRedContribs(
  99                         $this->user->getId(),
 100                         $this->user->getName(),
 101                         $this->user->getEditCount()
 102                 );
 103
 104                 $titleLink = Linker::link( $this->title, null, array(), array() );
 105
 106                 // $paramsWithoutTools and $paramsWithTools should be only different
 107                 // in index 0
 108                 $this->assertEquals( $paramsWithoutTools[1], $paramsWithTools[1] );
 109                 $this->assertEquals( $paramsWithoutTools[2], $paramsWithTools[2] );
 110
 111                 $this->assertEquals( $userLink, $paramsWithoutTools[0]['raw'] );
 112                 $this->assertEquals( $userLink . $userTools, $paramsWithTools[0]['raw'] );
 113
 114                 $this->assertEquals( $this->user->getName(), $paramsWithoutTools[1] );
 115
 116                 $this->assertEquals( $titleLink, $paramsWithoutTools[2]['raw'] );
 117         }
 118
 119         /**
 120          * @covers LogFormatter::newFromEntry
 121          * @covers LogFormatter::getActionText
 122          */
 123         public function testLogParamsTypeRaw() {
 124                 $params = array( '4:raw:raw' => Linker::link( $this->title, null, array(), array() ) );
 125                 $expected = Linker::link( $this->title, null, array(), array() );
 126
 127                 $entry = $this->newLogEntry( 'param', $params );
 128                 $formatter = LogFormatter::newFromEntry( $entry );
 129                 $formatter->setContext( $this->context );
 130
 131                 $logParam = $formatter->getActionText();
 132
 133                 $this->assertEquals( $expected, $logParam );
 134         }
 135
 136         /**
 137          * @covers LogFormatter::newFromEntry
 138          * @covers LogFormatter::getActionText
 139          */
 140         public function testLogParamsTypeMsg() {
 141                 $params = array( '4:msg:msg' => 'log-description-phpunit' );
 142                 $expected = wfMessage( 'log-description-phpunit' )->text();
 143
 144                 $entry = $this->newLogEntry( 'param', $params );
 145                 $formatter = LogFormatter::newFromEntry( $entry );
 146                 $formatter->setContext( $this->context );
 147
 148                 $logParam = $formatter->getActionText();
 149
 150                 $this->assertEquals( $expected, $logParam );
 151         }
 152
 153         /**
 154          * @covers LogFormatter::newFromEntry
 155          * @covers LogFormatter::getActionText
 156          */
 157         public function testLogParamsTypeMsgContent() {
 158                 $params = array( '4:msg-content:msgContent' => 'log-description-phpunit' );
 159                 $expected = wfMessage( 'log-description-phpunit' )->inContentLanguage()->text();
 160
 161                 $entry = $this->newLogEntry( 'param', $params );
 162                 $formatter = LogFormatter::newFromEntry( $entry );
 163                 $formatter->setContext( $this->context );
 164
 165                 $logParam = $formatter->getActionText();
 166
 167                 $this->assertEquals( $expected, $logParam );
 168         }
 169
 170         /**
 171          * @covers LogFormatter::newFromEntry
 172          * @covers LogFormatter::getActionText
 173          */
 174         public function testLogParamsTypeNumber() {
 175                 global $wgLang;
 176
 177                 $params = array( '4:number:number' => 123456789 );
 178                 $expected = $wgLang->formatNum( 123456789 );
 179
 180                 $entry = $this->newLogEntry( 'param', $params );
 181                 $formatter = LogFormatter::newFromEntry( $entry );
 182                 $formatter->setContext( $this->context );
 183
 184                 $logParam = $formatter->getActionText();
 185
 186                 $this->assertEquals( $expected, $logParam );
 187         }
 188
 189         /**
 190          * @covers LogFormatter::newFromEntry
 191          * @covers LogFormatter::getActionText
 192          */
 193         public function testLogParamsTypeUserLink() {
 194                 $params = array( '4:user-link:userLink' => $this->user->getName() );
 195                 $expected = Linker::userLink(
 196                         $this->user->getId(),
 197                         $this->user->getName()
 198                 );
 199
 200                 $entry = $this->newLogEntry( 'param', $params );
 201                 $formatter = LogFormatter::newFromEntry( $entry );
 202                 $formatter->setContext( $this->context );
 203
 204                 $logParam = $formatter->getActionText();
 205
 206                 $this->assertEquals( $expected, $logParam );
 207         }
 208
 209         /**
 210          * @covers LogFormatter::newFromEntry
 211          * @covers LogFormatter::getActionText
 212          */
 213         public function testLogParamsTypeTitleLink() {
 214                 $params = array( '4:title-link:titleLink' => $this->title->getText() );
 215                 $expected = Linker::link( $this->title, null, array(), array() );
 216
 217                 $entry = $this->newLogEntry( 'param', $params );
 218                 $formatter = LogFormatter::newFromEntry( $entry );
 219                 $formatter->setContext( $this->context );
 220
 221                 $logParam = $formatter->getActionText();
 222
 223                 $this->assertEquals( $expected, $logParam );
 224         }
 225
 226         /**
 227          * @covers LogFormatter::newFromEntry
 228          * @covers LogFormatter::getActionText
 229          */
 230         public function testLogParamsTypePlain() {
 231                 $params = array( '4:plain:plain' => 'Some plain text' );
 232                 $expected = 'Some plain text';
 233
 234                 $entry = $this->newLogEntry( 'param', $params );
 235                 $formatter = LogFormatter::newFromEntry( $entry );
 236                 $formatter->setContext( $this->context );
 237
 238                 $logParam = $formatter->getActionText();
 239
 240                 $this->assertEquals( $expected, $logParam );
 241         }
 242
 243         /**
 244          * @covers LogFormatter::newFromEntry
 245          * @covers LogFormatter::getComment
 246          */
 247         public function testLogComment() {
 248                 $entry = $this->newLogEntry( 'test', array() );
 249                 $formatter = LogFormatter::newFromEntry( $entry );
 250                 $formatter->setContext( $this->context );
 251
 252                 $comment = ltrim( Linker::commentBlock( $entry->getComment() ) );
 253
 254                 $this->assertEquals( $comment, $formatter->getComment() );
 255         }
 256
 257         /**
 258          * @dataProvider provideApiParamFormatting
 259          * @covers LogFormatter::formatParametersForApi
 260          * @covers LogFormatter::formatParameterValueForApi
 261          */
 262         public function testApiParamFormatting( $key, $value, $expected ) {
 263                 $entry = $this->newLogEntry( 'param', array( $key => $value ) );
 264                 $formatter = LogFormatter::newFromEntry( $entry );
 265                 $formatter->setContext( $this->context );
 266
 267                 ApiResult::setIndexedTagName( $expected, 'param' );
 268                 ApiResult::setArrayType( $expected, 'assoc' );
 269
 270                 $this->assertEquals( $expected, $formatter->formatParametersForApi() );
 271         }
 272
 273         public static function provideApiParamFormatting() {
 274                 return array(
 275                         array( 0, 'value', array( 'value' ) ),
 276                         array( 'named', 'value', array( 'named' => 'value' ) ),
 277                         array( '::key', 'value', array( 'key' => 'value' ) ),
 278                         array( '4::key', 'value', array( 'key' => 'value' ) ),
 279                         array( '4:raw:key', 'value', array( 'key' => 'value' ) ),
 280                         array( '4:plain:key', 'value', array( 'key' => 'value' ) ),
 281                         array( '4:bool:key', '1', array( 'key' => true ) ),
 282                         array( '4:bool:key', '0', array( 'key' => false ) ),
 283                         array( '4:number:key', '123', array( 'key' => 123 ) ),
 284                         array( '4:number:key', '123.5', array( 'key' => 123.5 ) ),
 285                         array( '4:array:key', array(), array( 'key' => array( ApiResult::META_TYPE => 'array' ) ) ),
 286                         array( '4:assoc:key', array(), array( 'key' => array( ApiResult::META_TYPE => 'assoc' ) ) ),
 287                         array( '4:kvp:key', array(), array( 'key' => array( ApiResult::META_TYPE => 'kvp' ) ) ),
 288                         array( '4:timestamp:key', '20150102030405', array( 'key' => '2015-01-02T03:04:05Z' ) ),
 289                         array( '4:msg:key', 'parentheses', array(
 290                                 'key_key' => 'parentheses',
 291                                 'key_text' => wfMessage( 'parentheses' )->text(),
 292                         ) ),
 293                         array( '4:msg-content:key', 'parentheses', array(
 294                                 'key_key' => 'parentheses',
 295                                 'key_text' => wfMessage( 'parentheses' )->inContentLanguage()->text(),
 296                         ) ),
 297                         array( '4:title:key', 'project:foo', array(
 298                                 'key_ns' => NS_PROJECT,
 299                                 'key_title' => Title::newFromText( 'project:foo' )->getFullText(),
 300                         ) ),
 301                         array( '4:title-link:key', 'project:foo', array(
 302                                 'key_ns' => NS_PROJECT,
 303                                 'key_title' => Title::newFromText( 'project:foo' )->getFullText(),
 304                         ) ),
 305                         array( '4:user:key', 'foo', array( 'key' => 'Foo' ) ),
 306                         array( '4:user-link:key', 'foo', array( 'key' => 'Foo' ) ),
 307                 );
 308         }
 309
 310         /**
 311          * The testIrcMsgForAction* tests are supposed to cover the hacky
 312          * LogFormatter::getIRCActionText / bug 34508
 313          *
 314          * Third parties bots listen to those messages. They are clever enough
 315          * to fetch the i18n messages from the wiki and then analyze the IRC feed
 316          * to reverse engineer the $1, $2 messages.
 317          * One thing bots can not detect is when MediaWiki change the meaning of
 318          * a message like what happened when we deployed 1.19. $1 became the user
 319          * performing the action which broke basically all bots around.
 320          *
 321          * Should cover the following log actions (which are most commonly used by bots):
 322          * - block/block
 323          * - block/unblock
 324          * - block/reblock
 325          * - delete/delete
 326          * - delete/restore
 327          * - newusers/create
 328          * - newusers/create2
 329          * - newusers/autocreate
 330          * - move/move
 331          * - move/move_redir
 332          * - protect/protect
 333          * - protect/modifyprotect
 334          * - protect/unprotect
 335          * - protect/move_prot
 336          * - upload/upload
 337          * - merge/merge
 338          * - import/upload
 339          * - import/interwiki
 340          *
 341          * As well as the following Auto Edit Summaries:
 342          * - blank
 343          * - replace
 344          * - rollback
 345          * - undo
 346          */
 347
 348         /**
 349          * @covers LogFormatter::getIRCActionComment
 350          * @covers LogFormatter::getIRCActionText
 351          */
 352         public function testIrcMsgForLogTypeBlock() {
 353                 $sep = $this->context->msg( 'colon-separator' )->text();
 354
 355                 # block/block
 356                 $this->assertIRCComment(
 357                         $this->context->msg( 'blocklogentry', 'SomeTitle', 'duration', '(flags)' )->plain()
 358                         . $sep . $this->user_comment,
 359                         'block', 'block',
 360                         array(
 361                                 '5::duration' => 'duration',
 362                                 '6::flags' => 'flags',
 363                         ),
 364                         $this->user_comment
 365                 );
 366                 # block/block - legacy
 367                 $this->assertIRCComment(
 368                         $this->context->msg( 'blocklogentry', 'SomeTitle', 'duration', '(flags)' )->plain()
 369                         . $sep . $this->user_comment,
 370                         'block', 'block',
 371                         array(
 372                                 'duration',
 373                                 'flags',
 374                         ),
 375                         $this->user_comment,
 376                         '',
 377                         true
 378                 );
 379                 # block/unblock
 380                 $this->assertIRCComment(
 381                         $this->context->msg( 'unblocklogentry', 'SomeTitle' )->plain() . $sep . $this->user_comment,
 382                         'block', 'unblock',
 383                         array(),
 384                         $this->user_comment
 385                 );
 386                 # block/reblock
 387                 $this->assertIRCComment(
 388                         $this->context->msg( 'reblock-logentry', 'SomeTitle', 'duration', '(flags)' )->plain()
 389                         . $sep . $this->user_comment,
 390                         'block', 'reblock',
 391                         array(
 392                                 '5::duration' => 'duration',
 393                                 '6::flags' => 'flags',
 394                         ),
 395                         $this->user_comment
 396                 );
 397         }
 398
 399         /**
 400          * @covers LogFormatter::getIRCActionComment
 401          * @covers LogFormatter::getIRCActionText
 402          */
 403         public function testIrcMsgForLogTypeDelete() {
 404                 $sep = $this->context->msg( 'colon-separator' )->text();
 405
 406                 # delete/delete
 407                 $this->assertIRCComment(
 408                         $this->context->msg( 'deletedarticle', 'SomeTitle' )->plain() . $sep . $this->user_comment,
 409                         'delete', 'delete',
 410                         array(),
 411                         $this->user_comment
 412                 );
 413
 414                 # delete/restore
 415                 $this->assertIRCComment(
 416                         $this->context->msg( 'undeletedarticle', 'SomeTitle' )->plain() . $sep . $this->user_comment,
 417                         'delete', 'restore',
 418                         array(),
 419                         $this->user_comment
 420                 );
 421         }
 422
 423         /**
 424          * @covers LogFormatter::getIRCActionComment
 425          * @covers LogFormatter::getIRCActionText
 426          */
 427         public function testIrcMsgForLogTypeNewusers() {
 428                 $this->assertIRCComment(
 429                         'New user account',
 430                         'newusers', 'newusers',
 431                         array()
 432                 );
 433                 $this->assertIRCComment(
 434                         'New user account',
 435                         'newusers', 'create',
 436                         array()
 437                 );
 438                 $this->assertIRCComment(
 439                         'created new account SomeTitle',
 440                         'newusers', 'create2',
 441                         array()
 442                 );
 443                 $this->assertIRCComment(
 444                         'Account created automatically',
 445                         'newusers', 'autocreate',
 446                         array()
 447                 );
 448         }
 449
 450         /**
 451          * @covers LogFormatter::getIRCActionComment
 452          * @covers LogFormatter::getIRCActionText
 453          */
 454         public function testIrcMsgForLogTypeMove() {
 455                 $move_params = array(
 456                         '4::target' => $this->target->getPrefixedText(),
 457                         '5::noredir' => 0,
 458                 );
 459                 $sep = $this->context->msg( 'colon-separator' )->text();
 460
 461                 # move/move
 462                 $this->assertIRCComment(
 463                         $this->context->msg( '1movedto2', 'SomeTitle', 'TestTarget' )
 464                                 ->plain() . $sep . $this->user_comment,
 465                         'move', 'move',
 466                         $move_params,
 467                         $this->user_comment
 468                 );
 469
 470                 # move/move_redir
 471                 $this->assertIRCComment(
 472                         $this->context->msg( '1movedto2_redir', 'SomeTitle', 'TestTarget' )
 473                                 ->plain() . $sep . $this->user_comment,
 474                         'move', 'move_redir',
 475                         $move_params,
 476                         $this->user_comment
 477                 );
 478         }
 479
 480         /**
 481          * @covers LogFormatter::getIRCActionComment
 482          * @covers LogFormatter::getIRCActionText
 483          */
 484         public function testIrcMsgForLogTypePatrol() {
 485                 # patrol/patrol
 486                 $this->assertIRCComment(
 487                         $this->context->msg( 'patrol-log-line', 'revision 777', '[[SomeTitle]]', '' )->plain(),
 488                         'patrol', 'patrol',
 489                         array(
 490                                 '4::curid' => '777',
 491                                 '5::previd' => '666',
 492                                 '6::auto' => 0,
 493                         )
 494                 );
 495         }
 496
 497         /**
 498          * @covers LogFormatter::getIRCActionComment
 499          * @covers LogFormatter::getIRCActionText
 500          */
 501         public function testIrcMsgForLogTypeProtect() {
 502                 $protectParams = array(
 503                         '4::description' => '[edit=sysop] (indefinite) ‎[move=sysop] (indefinite)'
 504                 );
 505                 $sep = $this->context->msg( 'colon-separator' )->text();
 506
 507                 # protect/protect
 508                 $this->assertIRCComment(
 509                         $this->context->msg( 'protectedarticle', 'SomeTitle ' . $protectParams['4::description'] )
 510                                 ->plain() . $sep . $this->user_comment,
 511                         'protect', 'protect',
 512                         $protectParams,
 513                         $this->user_comment
 514                 );
 515
 516                 # protect/unprotect
 517                 $this->assertIRCComment(
 518                         $this->context->msg( 'unprotectedarticle', 'SomeTitle' )->plain() . $sep . $this->user_comment,
 519                         'protect', 'unprotect',
 520                         array(),
 521                         $this->user_comment
 522                 );
 523
 524                 # protect/modify
 525                 $this->assertIRCComment(
 526                         $this->context->msg( 'modifiedarticleprotection', 'SomeTitle ' . $protectParams['4::description'] )
 527                                 ->plain() . $sep . $this->user_comment,
 528                         'protect', 'modify',
 529                         $protectParams,
 530                         $this->user_comment
 531                 );
 532
 533                 # protect/move_prot
 534                 $this->assertIRCComment(
 535                         $this->context->msg( 'movedarticleprotection', 'SomeTitle', 'OldTitle' )
 536                                 ->plain() . $sep . $this->user_comment,
 537                         'protect', 'move_prot',
 538                         array(
 539                                 '4::oldtitle' => 'OldTitle'
 540                         ),
 541                         $this->user_comment
 542                 );
 543         }
 544
 545         /**
 546          * @covers LogFormatter::getIRCActionComment
 547          * @covers LogFormatter::getIRCActionText
 548          */
 549         public function testIrcMsgForLogTypeUpload() {
 550                 $sep = $this->context->msg( 'colon-separator' )->text();
 551
 552                 # upload/upload
 553                 $this->assertIRCComment(
 554                         $this->context->msg( 'uploadedimage', 'SomeTitle' )->plain() . $sep . $this->user_comment,
 555                         'upload', 'upload',
 556                         array(),
 557                         $this->user_comment
 558                 );
 559
 560                 # upload/overwrite
 561                 $this->assertIRCComment(
 562                         $this->context->msg( 'overwroteimage', 'SomeTitle' )->plain() . $sep . $this->user_comment,
 563                         'upload', 'overwrite',
 564                         array(),
 565                         $this->user_comment
 566                 );
 567         }
 568
 569         /**
 570          * @covers LogFormatter::getIRCActionComment
 571          * @covers LogFormatter::getIRCActionText
 572          */
 573         public function testIrcMsgForLogTypeMerge() {
 574                 $sep = $this->context->msg( 'colon-separator' )->text();
 575
 576                 # merge/merge
 577                 $this->assertIRCComment(
 578                         $this->context->msg( 'pagemerge-logentry', 'SomeTitle', 'Dest', 'timestamp' )->plain()
 579                         . $sep . $this->user_comment,
 580                         'merge', 'merge',
 581                         array(
 582                                 '4::dest' => 'Dest',
 583                                 '5::mergepoint' => 'timestamp',
 584                         ),
 585                         $this->user_comment
 586                 );
 587         }
 588
 589         /**
 590          * @covers LogFormatter::getIRCActionComment
 591          * @covers LogFormatter::getIRCActionText
 592          */
 593         public function testIrcMsgForLogTypeImport() {
 594                 $sep = $this->context->msg( 'colon-separator' )->text();
 595
 596                 # import/upload
 597                 $msg = $this->context->msg( 'import-logentry-upload', 'SomeTitle' )->plain() .
 598                         $sep .
 599                         $this->user_comment;
 600                 $this->assertIRCComment(
 601                         $msg,
 602                         'import', 'upload',
 603                         array(),
 604                         $this->user_comment
 605                 );
 606
 607                 # import/interwiki
 608                 $msg = $this->context->msg( 'import-logentry-interwiki', 'SomeTitle' )->plain() .
 609                         $sep .
 610                         $this->user_comment;
 611                 $this->assertIRCComment(
 612                         $msg,
 613                         'import', 'interwiki',
 614                         array(),
 615                         $this->user_comment
 616                 );
 617         }
 618
 619         /**
 620          * @param string $expected Expected IRC text without colors codes
 621          * @param string $type Log type (move, delete, suppress, patrol ...)
 622          * @param string $action A log type action
 623          * @param array $params
 624          * @param string $comment (optional) A comment for the log action
 625          * @param string $msg (optional) A message for PHPUnit :-)
 626          */
 627         protected function assertIRCComment( $expected, $type, $action, $params,
 628                 $comment = null, $msg = '', $legacy = false
 629         ) {
 630                 $logEntry = new ManualLogEntry( $type, $action );
 631                 $logEntry->setPerformer( $this->user );
 632                 $logEntry->setTarget( $this->title );
 633                 if ( $comment !== null ) {
 634                         $logEntry->setComment( $comment );
 635                 }
 636                 $logEntry->setParameters( $params );
 637                 $logEntry->setLegacy( $legacy );
 638
 639                 $formatter = LogFormatter::newFromEntry( $logEntry );
 640                 $formatter->setContext( $this->context );
 641
 642                 // Apply the same transformation as done in IRCColourfulRCFeedFormatter::getLine for rc_comment
 643                 $ircRcComment = IRCColourfulRCFeedFormatter::cleanupForIRC( $formatter->getIRCActionComment() );
 644
 645                 $this->assertEquals(
 646                         $expected,
 647                         $ircRcComment,
 648                         $msg
 649                 );
 650         }
 651
 652 }