tests/phpunit/includes/StatusTest.php

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