tests/phpunit/includes/logging/LogFormatterTest.php

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