tests/phpunit/includes/StatusTest.php

   1 <?php
   2
   3 /**
   4  * @author Addshore
   5  */
   6 class StatusTest extends MediaWikiLangTestCase {
   7
   8         public function testCanConstruct() {
   9                 new Status();
  10                 $this->assertTrue( true );
  11         }
  12
  13         /**
  14          * @dataProvider provideValues
  15          * @covers Status::newGood
  16          */
  17         public function testNewGood( $value = null ) {
  18                 $status = Status::newGood( $value );
  19                 $this->assertTrue( $status->isGood() );
  20                 $this->assertTrue( $status->isOK() );
  21                 $this->assertEquals( $value, $status->getValue() );
  22         }
  23
  24         public static function provideValues() {
  25                 return [
  26                         [],
  27                         [ 'foo' ],
  28                         [ [ 'foo' => 'bar' ] ],
  29                         [ new Exception() ],
  30                         [ 1234 ],
  31                 ];
  32         }
  33
  34         /**
  35          * @covers Status::newFatal
  36          */
  37         public function testNewFatalWithMessage() {
  38                 $message = $this->getMockBuilder( 'Message' )
  39                         ->disableOriginalConstructor()
  40                         ->getMock();
  41
  42                 $status = Status::newFatal( $message );
  43                 $this->assertFalse( $status->isGood() );
  44                 $this->assertFalse( $status->isOK() );
  45                 $this->assertEquals( $message, $status->getMessage() );
  46         }
  47
  48         /**
  49          * @covers Status::newFatal
  50          */
  51         public function testNewFatalWithString() {
  52                 $message = 'foo';
  53                 $status = Status::newFatal( $message );
  54                 $this->assertFalse( $status->isGood() );
  55                 $this->assertFalse( $status->isOK() );
  56                 $this->assertEquals( $message, $status->getMessage()->getKey() );
  57         }
  58
  59         /**
  60          *
  61          */
  62         public function testOkAndErrors() {
  63                 $status = Status::newGood( 'foo' );
  64                 $this->assertTrue( $status->ok );
  65                 $status = Status::newFatal( 'foo', 1, 2 );
  66                 $this->assertFalse( $status->ok );
  67                 $this->assertArrayEquals(
  68                         [
  69                                 [
  70                                         'type' => 'error',
  71                                         'message' => 'foo',
  72                                         'params' => [ 1, 2 ]
  73                                 ]
  74                         ],
  75                         $status->errors
  76                 );
  77         }
  78
  79         /**
  80          * @dataProvider provideSetResult
  81          * @covers Status::setResult
  82          */
  83         public function testSetResult( $ok, $value = null ) {
  84                 $status = new Status();
  85                 $status->setResult( $ok, $value );
  86                 $this->assertEquals( $ok, $status->isOK() );
  87                 $this->assertEquals( $value, $status->getValue() );
  88         }
  89
  90         public static function provideSetResult() {
  91                 return [
  92                         [ true ],
  93                         [ false ],
  94                         [ true, 'value' ],
  95                         [ false, 'value' ],
  96                 ];
  97         }
  98
  99         /**
 100          * @dataProvider provideIsOk
 101          * @covers Status::isOk
 102          */
 103         public function testIsOk( $ok ) {
 104                 $status = new Status();
 105                 $status->ok = $ok;
 106                 $this->assertEquals( $ok, $status->isOK() );
 107         }
 108
 109         public static function provideIsOk() {
 110                 return [
 111                         [ true ],
 112                         [ false ],
 113                 ];
 114         }
 115
 116         /**
 117          * @covers Status::getValue
 118          */
 119         public function testGetValue() {
 120                 $status = new Status();
 121                 $status->value = 'foobar';
 122                 $this->assertEquals( 'foobar', $status->getValue() );
 123         }
 124
 125         /**
 126          * @dataProvider provideIsGood
 127          * @covers Status::isGood
 128          */
 129         public function testIsGood( $ok, $errors, $expected ) {
 130                 $status = new Status();
 131                 $status->ok = $ok;
 132                 foreach ( $errors as $error ) {
 133                         $status->warning( $error );
 134                 }
 135                 $this->assertEquals( $expected, $status->isGood() );
 136         }
 137
 138         public static function provideIsGood() {
 139                 return [
 140                         [ true, [], true ],
 141                         [ true, [ 'foo' ], false ],
 142                         [ false, [], false ],
 143                         [ false, [ 'foo' ], false ],
 144                 ];
 145         }
 146
 147         /**
 148          * @dataProvider provideMockMessageDetails
 149          * @covers Status::warning
 150          * @covers Status::getWarningsArray
 151          * @covers Status::getStatusArray
 152          */
 153         public function testWarningWithMessage( $mockDetails ) {
 154                 $status = new Status();
 155                 $messages = $this->getMockMessages( $mockDetails );
 156
 157                 foreach ( $messages as $message ) {
 158                         $status->warning( $message );
 159                 }
 160                 $warnings = $status->getWarningsArray();
 161
 162                 $this->assertEquals( count( $messages ), count( $warnings ) );
 163                 foreach ( $messages as $key => $message ) {
 164                         $expectedArray = array_merge( [ $message->getKey() ], $message->getParams() );
 165                         $this->assertEquals( $warnings[$key], $expectedArray );
 166                 }
 167         }
 168
 169         /**
 170          * @dataProvider provideMockMessageDetails
 171          * @covers Status::error
 172          * @covers Status::getErrorsArray
 173          * @covers Status::getStatusArray
 174          */
 175         public function testErrorWithMessage( $mockDetails ) {
 176                 $status = new Status();
 177                 $messages = $this->getMockMessages( $mockDetails );
 178
 179                 foreach ( $messages as $message ) {
 180                         $status->error( $message );
 181                 }
 182                 $errors = $status->getErrorsArray();
 183
 184                 $this->assertEquals( count( $messages ), count( $errors ) );
 185                 foreach ( $messages as $key => $message ) {
 186                         $expectedArray = array_merge( [ $message->getKey() ], $message->getParams() );
 187                         $this->assertEquals( $errors[$key], $expectedArray );
 188                 }
 189         }
 190
 191         /**
 192          * @dataProvider provideMockMessageDetails
 193          * @covers Status::fatal
 194          * @covers Status::getErrorsArray
 195          * @covers Status::getStatusArray
 196          */
 197         public function testFatalWithMessage( $mockDetails ) {
 198                 $status = new Status();
 199                 $messages = $this->getMockMessages( $mockDetails );
 200
 201                 foreach ( $messages as $message ) {
 202                         $status->fatal( $message );
 203                 }
 204                 $errors = $status->getErrorsArray();
 205
 206                 $this->assertEquals( count( $messages ), count( $errors ) );
 207                 foreach ( $messages as $key => $message ) {
 208                         $expectedArray = array_merge( [ $message->getKey() ], $message->getParams() );
 209                         $this->assertEquals( $errors[$key], $expectedArray );
 210                 }
 211                 $this->assertFalse( $status->isOK() );
 212         }
 213
 214         protected function getMockMessage( $key = 'key', $params = [] ) {
 215                 $message = $this->getMockBuilder( 'Message' )
 216                         ->disableOriginalConstructor()
 217                         ->getMock();
 218                 $message->expects( $this->atLeastOnce() )
 219                         ->method( 'getKey' )
 220                         ->will( $this->returnValue( $key ) );
 221                 $message->expects( $this->atLeastOnce() )
 222                         ->method( 'getParams' )
 223                         ->will( $this->returnValue( $params ) );
 224                 return $message;
 225         }
 226
 227         /**
 228          * @param array $messageDetails E.g. array( 'KEY' => array(/PARAMS/) )
 229          * @return Message[]
 230          */
 231         protected function getMockMessages( $messageDetails ) {
 232                 $messages = [];
 233                 foreach ( $messageDetails as $key => $paramsArray ) {
 234                         $messages[] = $this->getMockMessage( $key, $paramsArray );
 235                 }
 236                 return $messages;
 237         }
 238
 239         public static function provideMockMessageDetails() {
 240                 return [
 241                         [ [ 'key1' => [ 'foo' => 'bar' ] ] ],
 242                         [ [ 'key1' => [ 'foo' => 'bar' ], 'key2' => [ 'foo2' => 'bar2' ] ] ],
 243                 ];
 244         }
 245
 246         /**
 247          * @covers Status::merge
 248          */
 249         public function testMerge() {
 250                 $status1 = new Status();
 251                 $status2 = new Status();
 252                 $message1 = $this->getMockMessage( 'warn1' );
 253                 $message2 = $this->getMockMessage( 'error2' );
 254                 $status1->warning( $message1 );
 255                 $status2->error( $message2 );
 256
 257                 $status1->merge( $status2 );
 258                 $this->assertEquals(
 259                         2,
 260                         count( $status1->getWarningsArray() ) + count( $status1->getErrorsArray() )
 261                 );
 262         }
 263
 264         /**
 265          * @covers Status::merge
 266          */
 267         public function testMergeWithOverwriteValue() {
 268                 $status1 = new Status();
 269                 $status2 = new Status();
 270                 $message1 = $this->getMockMessage( 'warn1' );
 271                 $message2 = $this->getMockMessage( 'error2' );
 272                 $status1->warning( $message1 );
 273                 $status2->error( $message2 );
 274                 $status2->value = 'FooValue';
 275
 276                 $status1->merge( $status2, true );
 277                 $this->assertEquals(
 278                         2,
 279                         count( $status1->getWarningsArray() ) + count( $status1->getErrorsArray() )
 280                 );
 281                 $this->assertEquals( 'FooValue', $status1->getValue() );
 282         }
 283
 284         /**
 285          * @covers Status::hasMessage
 286          */
 287         public function testHasMessage() {
 288                 $status = new Status();
 289                 $status->fatal( 'bad' );
 290                 $status->fatal( wfMessage( 'bad-msg' ) );
 291                 $this->assertTrue( $status->hasMessage( 'bad' ) );
 292                 $this->assertTrue( $status->hasMessage( 'bad-msg' ) );
 293                 $this->assertTrue( $status->hasMessage( wfMessage( 'bad-msg' ) ) );
 294                 $this->assertFalse( $status->hasMessage( 'good' ) );
 295         }
 296
 297         /**
 298          * @dataProvider provideCleanParams
 299          * @covers Status::cleanParams
 300          */
 301         public function testCleanParams( $cleanCallback, $params, $expected ) {
 302                 $method = new ReflectionMethod( 'Status', 'cleanParams' );
 303                 $method->setAccessible( true );
 304                 $status = new Status();
 305                 $status->cleanCallback = $cleanCallback;
 306
 307                 $this->assertEquals( $expected, $method->invoke( $status, $params ) );
 308         }
 309
 310         public static function provideCleanParams() {
 311                 $cleanCallback = function ( $value ) {
 312                         return '-' . $value . '-';
 313                 };
 314
 315                 return [
 316                         [ false, [ 'foo' => 'bar' ], [ 'foo' => 'bar' ] ],
 317                         [ $cleanCallback, [ 'foo' => 'bar' ], [ 'foo' => '-bar-' ] ],
 318                 ];
 319         }
 320
 321         /**
 322          * @dataProvider provideGetWikiTextAndHtml
 323          * @covers Status::getWikiText
 324          * @todo test long and short context messages generated through this method
 325          *       this can not really be done now due to use of wfMessage()->plain()
 326          *       It is possible to mock such methods but only if namespaces are used
 327          */
 328         public function testGetWikiText( Status $status, $wikitext, $html ) {
 329                 $this->assertEquals( $wikitext, $status->getWikiText() );
 330         }
 331
 332         /**
 333          * @dataProvider provideGetWikiTextAndHtml
 334          * @covers Status::getHtml
 335          * @todo test long and short context messages generated through this method
 336          *   this can not really be done now due to use of $this->getWikiText using
 337          *   wfMessage()->plain(). It is possible to mock such methods but only if
 338          *   namespaces are used.
 339          */
 340         public function testGetHtml( Status $status, $wikitext, $html ) {
 341                 $this->assertEquals( $html, $status->getHTML() );
 342         }
 343
 344         /**
 345          * @return array Array of arrays with values;
 346          *    0 => status object
 347          *    1 => expected string (with no context)
 348          */
 349         public static function provideGetWikiTextAndHtml() {
 350                 $testCases = [];
 351
 352                 $testCases['GoodStatus'] = [
 353                         new Status(),
 354                         "Internal error: Status::getWikiText called for a good result, this is incorrect\n",
 355                         "<p>Internal error: Status::getWikiText called for a good result, this is incorrect\n</p>",
 356                 ];
 357
 358                 $status = new Status();
 359                 $status->ok = false;
 360                 $testCases['GoodButNoError'] = [
 361                         $status,
 362                         "Internal error: Status::getWikiText: Invalid result object: no error text but not OK\n",
 363                         "<p>Internal error: Status::getWikiText: Invalid result object: no error text but not OK\n</p>",
 364                 ];
 365
 366                 $status = new Status();
 367                 $status->warning( 'fooBar!' );
 368                 $testCases['1StringWarning'] = [
 369                         $status,
 370                         "<fooBar!>",
 371                         "<p>&lt;fooBar!&gt;\n</p>",
 372                 ];
 373
 374                 $status = new Status();
 375                 $status->warning( 'fooBar!' );
 376                 $status->warning( 'fooBar2!' );
 377                 $testCases['2StringWarnings'] = [
 378                         $status,
 379                         "* <fooBar!>\n* <fooBar2!>\n",
 380                         "<ul><li> &lt;fooBar!&gt;</li>\n<li> &lt;fooBar2!&gt;</li></ul>\n",
 381                 ];
 382
 383                 $status = new Status();
 384                 $status->warning( new Message( 'fooBar!', [ 'foo', 'bar' ] ) );
 385                 $testCases['1MessageWarning'] = [
 386                         $status,
 387                         "<fooBar!>",
 388                         "<p>&lt;fooBar!&gt;\n</p>",
 389                 ];
 390
 391                 $status = new Status();
 392                 $status->warning( new Message( 'fooBar!', [ 'foo', 'bar' ] ) );
 393                 $status->warning( new Message( 'fooBar2!' ) );
 394                 $testCases['2MessageWarnings'] = [
 395                         $status,
 396                         "* <fooBar!>\n* <fooBar2!>\n",
 397                         "<ul><li> &lt;fooBar!&gt;</li>\n<li> &lt;fooBar2!&gt;</li></ul>\n",
 398                 ];
 399
 400                 return $testCases;
 401         }
 402
 403         /**
 404          * @dataProvider provideGetMessage
 405          * @covers Status::getMessage
 406          * @todo test long and short context messages generated through this method
 407          */
 408         public function testGetMessage( Status $status, $expectedParams = [], $expectedKey ) {
 409                 $message = $status->getMessage();
 410                 $this->assertInstanceOf( 'Message', $message );
 411                 $this->assertEquals( $expectedParams, $message->getParams(), 'Message::getParams' );
 412                 $this->assertEquals( $expectedKey, $message->getKey(), 'Message::getKey' );
 413         }
 414
 415         /**
 416          * @return array Array of arrays with values;
 417          *    0 => status object
 418          *    1 => expected Message parameters (with no context)
 419          *    2 => expected Message key
 420          */
 421         public static function provideGetMessage() {
 422                 $testCases = [];
 423
 424                 $testCases['GoodStatus'] = [
 425                         new Status(),
 426                         [ "Status::getMessage called for a good result, this is incorrect\n" ],
 427                         'internalerror_info'
 428                 ];
 429
 430                 $status = new Status();
 431                 $status->ok = false;
 432                 $testCases['GoodButNoError'] = [
 433                         $status,
 434                         [ "Status::getMessage: Invalid result object: no error text but not OK\n" ],
 435                         'internalerror_info'
 436                 ];
 437
 438                 $status = new Status();
 439                 $status->warning( 'fooBar!' );
 440                 $testCases['1StringWarning'] = [
 441                         $status,
 442                         [],
 443                         'fooBar!'
 444                 ];
 445
 446                 // FIXME: Assertion tries to compare a StubUserLang with a Language object, because
 447                 // "data providers are executed before both the call to the setUpBeforeClass static method
 448                 // and the first call to the setUp method. Because of that you can't access any variables
 449                 // you create there from within a data provider."
 450                 // http://phpunit.de/manual/3.7/en/writing-tests-for-phpunit.html
 451 //              $status = new Status();
 452 //              $status->warning( 'fooBar!' );
 453 //              $status->warning( 'fooBar2!' );
 454 //              $testCases[ '2StringWarnings' ] = array(
 455 //                      $status,
 456 //                      array( new Message( 'fooBar!' ), new Message( 'fooBar2!' ) ),
 457 //                      "* \$1\n* \$2"
 458 //              );
 459
 460                 $status = new Status();
 461                 $status->warning( new Message( 'fooBar!', [ 'foo', 'bar' ] ) );
 462                 $testCases['1MessageWarning'] = [
 463                         $status,
 464                         [ 'foo', 'bar' ],
 465                         'fooBar!'
 466                 ];
 467
 468                 $status = new Status();
 469                 $status->warning( new Message( 'fooBar!', [ 'foo', 'bar' ] ) );
 470                 $status->warning( new Message( 'fooBar2!' ) );
 471                 $testCases['2MessageWarnings'] = [
 472                         $status,
 473                         [ new Message( 'fooBar!', [ 'foo', 'bar' ] ), new Message( 'fooBar2!' ) ],
 474                         "* \$1\n* \$2"
 475                 ];
 476
 477                 return $testCases;
 478         }
 479
 480         /**
 481          * @covers Status::replaceMessage
 482          */
 483         public function testReplaceMessage() {
 484                 $status = new Status();
 485                 $message = new Message( 'key1', [ 'foo1', 'bar1' ] );
 486                 $status->error( $message );
 487                 $newMessage = new Message( 'key2', [ 'foo2', 'bar2' ] );
 488
 489                 $status->replaceMessage( $message, $newMessage );
 490
 491                 $this->assertEquals( $newMessage, $status->errors[0]['message'] );
 492         }
 493
 494         /**
 495          * @covers Status::getErrorMessage
 496          */
 497         public function testGetErrorMessage() {
 498                 $method = new ReflectionMethod( 'Status', 'getErrorMessage' );
 499                 $method->setAccessible( true );
 500                 $status = new Status();
 501                 $key = 'foo';
 502                 $params = [ 'bar' ];
 503
 504                 /** @var Message $message */
 505                 $message = $method->invoke( $status, array_merge( [ $key ], $params ) );
 506                 $this->assertInstanceOf( 'Message', $message );
 507                 $this->assertEquals( $key, $message->getKey() );
 508                 $this->assertEquals( $params, $message->getParams() );
 509         }
 510
 511         /**
 512          * @covers Status::getErrorMessageArray
 513          */
 514         public function testGetErrorMessageArray() {
 515                 $method = new ReflectionMethod( 'Status', 'getErrorMessageArray' );
 516                 $method->setAccessible( true );
 517                 $status = new Status();
 518                 $key = 'foo';
 519                 $params = [ 'bar' ];
 520
 521                 /** @var Message[] $messageArray */
 522                 $messageArray = $method->invoke(
 523                         $status,
 524                         [
 525                                 array_merge( [ $key ], $params ),
 526                                 array_merge( [ $key ], $params )
 527                         ]
 528                 );
 529
 530                 $this->assertInternalType( 'array', $messageArray );
 531                 $this->assertCount( 2, $messageArray );
 532                 foreach ( $messageArray as $message ) {
 533                         $this->assertInstanceOf( 'Message', $message );
 534                         $this->assertEquals( $key, $message->getKey() );
 535                         $this->assertEquals( $params, $message->getParams() );
 536                 }
 537         }
 538
 539         /**
 540          * @covers Status::getErrorsByType
 541          */
 542         public function testGetErrorsByType() {
 543                 $status = new Status();
 544                 $warning = new Message( 'warning111' );
 545                 $error = new Message( 'error111' );
 546                 $status->warning( $warning );
 547                 $status->error( $error );
 548
 549                 $warnings = $status->getErrorsByType( 'warning' );
 550                 $errors = $status->getErrorsByType( 'error' );
 551
 552                 $this->assertCount( 1, $warnings );
 553                 $this->assertCount( 1, $errors );
 554                 $this->assertEquals( $warning, $warnings[0]['message'] );
 555                 $this->assertEquals( $error, $errors[0]['message'] );
 556         }
 557
 558         /**
 559          * @covers Status::__wakeup
 560          */
 561         public function testWakeUpSanitizesCallback() {
 562                 $status = new Status();
 563                 $status->cleanCallback = function ( $value ) {
 564                         return '-' . $value . '-';
 565                 };
 566                 $status->__wakeup();
 567                 $this->assertEquals( false, $status->cleanCallback );
 568         }
 569
 570         /**
 571          * @dataProvider provideNonObjectMessages
 572          * @covers Status::getStatusArray
 573          */
 574         public function testGetStatusArrayWithNonObjectMessages( $nonObjMsg ) {
 575                 $status = new Status();
 576                 if ( !array_key_exists( 1, $nonObjMsg ) ) {
 577                         $status->warning( $nonObjMsg[0] );
 578                 } else {
 579                         $status->warning( $nonObjMsg[0], $nonObjMsg[1] );
 580                 }
 581
 582                 $array = $status->getWarningsArray(); // We use getWarningsArray to access getStatusArray
 583
 584                 $this->assertEquals( 1, count( $array ) );
 585                 $this->assertEquals( $nonObjMsg, $array[0] );
 586         }
 587
 588         public static function provideNonObjectMessages() {
 589                 return [
 590                         [ [ 'ImaString', [ 'param1' => 'value1' ] ] ],
 591                         [ [ 'ImaString' ] ],
 592                 ];
 593         }
 594
 595 }