tests/phpunit/includes/api/ApiErrorFormatterTest.php

   1 <?php
   2
   3 namespace MediaWiki\Tests\Api;
   4
   5 use Exception;
   6 use LocalizedException;
   7 use MediaWiki\Api\ApiErrorFormatter;
   8 use MediaWiki\Api\ApiErrorFormatter_BackCompat;
   9 use MediaWiki\Api\ApiMessage;
  10 use MediaWiki\Api\ApiResult;
  11 use MediaWiki\Api\IApiMessage;
  12 use MediaWiki\Language\RawMessage;
  13 use MediaWiki\Message\Message;
  14 use MediaWiki\Status\Status;
  15 use MediaWikiLangTestCase;
  16 use RuntimeException;
  17 use Wikimedia\TestingAccessWrapper;
  18
  19 /**
  20  * @group API
  21  */
  22 class ApiErrorFormatterTest extends MediaWikiLangTestCase {
  23
  24         /**
  25          * @covers \MediaWiki\Api\ApiErrorFormatter
  26          */
  27         public function testErrorFormatterBasics() {
  28                 $result = new ApiResult( 8_388_608 );
  29                 $formatter = new ApiErrorFormatter( $result,
  30                         $this->getServiceContainer()->getLanguageFactory()->getLanguage( 'de' ), 'wikitext',
  31                         false );
  32                 $this->assertSame( 'de', $formatter->getLanguage()->getCode() );
  33                 $this->assertSame( 'wikitext', $formatter->getFormat() );
  34
  35                 $formatter->addMessagesFromStatus( null, Status::newGood() );
  36                 $this->assertSame(
  37                         [ ApiResult::META_TYPE => 'assoc' ],
  38                         $result->getResultData()
  39                 );
  40
  41                 $this->assertSame( [], $formatter->arrayFromStatus( Status::newGood() ) );
  42
  43                 $wrappedFormatter = TestingAccessWrapper::newFromObject( $formatter );
  44                 $this->assertSame(
  45                         'Blah "kbd" <X> 😊',
  46                         $wrappedFormatter->stripMarkup( 'Blah <kbd>kbd</kbd> <b>&lt;X&gt;</b> &#x1f60a;' ),
  47                         'stripMarkup'
  48                 );
  49         }
  50
  51         /**
  52          * @covers \MediaWiki\Api\ApiErrorFormatter
  53          * @covers \MediaWiki\Api\ApiErrorFormatter_BackCompat
  54          */
  55         public function testNewWithFormat() {
  56                 $result = new ApiResult( 8_388_608 );
  57                 $formatter = new ApiErrorFormatter( $result,
  58                         $this->getServiceContainer()->getLanguageFactory()->getLanguage( 'de' ), 'wikitext',
  59                         false );
  60                 $formatter2 = $formatter->newWithFormat( 'html' );
  61
  62                 $this->assertSame( $formatter->getLanguage(), $formatter2->getLanguage() );
  63                 $this->assertSame( 'html', $formatter2->getFormat() );
  64
  65                 $formatter3 = new ApiErrorFormatter_BackCompat( $result );
  66                 $formatter4 = $formatter3->newWithFormat( 'html' );
  67                 $this->assertNotInstanceOf( ApiErrorFormatter_BackCompat::class, $formatter4 );
  68                 $this->assertSame( $formatter3->getLanguage(), $formatter4->getLanguage() );
  69                 $this->assertSame( 'html', $formatter4->getFormat() );
  70         }
  71
  72         /**
  73          * @covers \MediaWiki\Api\ApiErrorFormatter
  74          * @dataProvider provideErrorFormatter
  75          */
  76         public function testErrorFormatter( $format, $lang, $useDB,
  77                 $expect1, $expect2, $expect3
  78         ) {
  79                 $result = new ApiResult( 8_388_608 );
  80                 $formatter = new ApiErrorFormatter( $result,
  81                         $this->getServiceContainer()->getLanguageFactory()->getLanguage( $lang ), $format,
  82                         $useDB );
  83
  84                 // Add default type
  85                 $expect1[ApiResult::META_TYPE] = 'assoc';
  86                 $expect2[ApiResult::META_TYPE] = 'assoc';
  87                 $expect3[ApiResult::META_TYPE] = 'assoc';
  88
  89                 $formatter->addWarning( 'string', 'mainpage' );
  90                 $formatter->addError( 'err', 'aboutpage' );
  91                 $this->assertEquals( $expect1, $result->getResultData(), 'Simple test' );
  92
  93                 $result->reset();
  94                 $formatter->addWarning( 'foo', 'mainpage' );
  95                 $formatter->addWarning( 'foo', 'mainpage' );
  96                 $formatter->addWarning( 'foo', [ 'parentheses', 'foobar' ] );
  97                 $msg1 = wfMessage( 'copyright' );
  98                 $formatter->addWarning( 'message', $msg1 );
  99                 $msg2 = new ApiMessage( 'disclaimers', 'overriddenCode', [ 'overriddenData' => true ] );
 100                 $formatter->addWarning( 'messageWithData', $msg2 );
 101                 $msg3 = new ApiMessage( 'edithelp', 'overriddenCode', [ 'overriddenData' => true ] );
 102                 $formatter->addError( 'errWithData', $msg3 );
 103                 $this->assertSame( $expect2, $result->getResultData(), 'Complex test' );
 104
 105                 $this->assertEquals(
 106                         $this->removeModuleTag( $expect2['warnings'][2] ),
 107                         $formatter->formatMessage( $msg1 ),
 108                         'formatMessage test 1'
 109                 );
 110                 $this->assertEquals(
 111                         $this->removeModuleTag( $expect2['warnings'][3] ),
 112                         $formatter->formatMessage( $msg2 ),
 113                         'formatMessage test 2'
 114                 );
 115
 116                 $result->reset();
 117                 $status = Status::newGood();
 118                 $status->warning( 'mainpage' );
 119                 $status->warning( 'parentheses', 'foobar' );
 120                 $status->warning( $msg1 );
 121                 $status->warning( $msg2 );
 122                 $status->error( 'aboutpage' );
 123                 $status->error( 'brackets', 'foobar' );
 124                 $formatter->addMessagesFromStatus( 'status', $status );
 125                 $this->assertSame( $expect3, $result->getResultData(), 'Status test' );
 126
 127                 $this->assertSame(
 128                         array_map( [ $this, 'removeModuleTag' ], $expect3['errors'] ),
 129                         $formatter->arrayFromStatus( $status, 'error' ),
 130                         'arrayFromStatus test for error'
 131                 );
 132                 $this->assertSame(
 133                         array_map( [ $this, 'removeModuleTag' ], $expect3['warnings'] ),
 134                         $formatter->arrayFromStatus( $status, 'warning' ),
 135                         'arrayFromStatus test for warning'
 136                 );
 137         }
 138
 139         private function removeModuleTag( $s ) {
 140                 if ( is_array( $s ) ) {
 141                         unset( $s['module'] );
 142                 }
 143                 return $s;
 144         }
 145
 146         private static function text( $msg ) {
 147                 return $msg->inLanguage( 'de' )->useDatabase( false )->text();
 148         }
 149
 150         private static function html( $msg ) {
 151                 return $msg->inLanguage( 'en' )->parse();
 152         }
 153
 154         public static function provideErrorFormatter() {
 155                 $aboutpage = wfMessage( 'aboutpage' );
 156                 $mainpage = wfMessage( 'mainpage' );
 157                 $parens = wfMessage( 'parentheses', 'foobar' );
 158                 $brackets = wfMessage( 'brackets', 'foobar' );
 159                 $copyright = wfMessage( 'copyright' );
 160                 $disclaimers = wfMessage( 'disclaimers' );
 161                 $edithelp = wfMessage( 'edithelp' );
 162
 163                 $C = ApiResult::META_CONTENT;
 164                 $I = ApiResult::META_INDEXED_TAG_NAME;
 165                 $overriddenData = [ 'overriddenData' => true, ApiResult::META_TYPE => 'assoc' ];
 166
 167                 return [
 168                         'zero' => $tmp = [ 'wikitext', 'de', false,
 169                                 [
 170                                         'errors' => [
 171                                                 [ 'code' => 'aboutpage', 'text' => self::text( $aboutpage ), 'module' => 'err', $C => 'text' ],
 172                                                 $I => 'error',
 173                                         ],
 174                                         'warnings' => [
 175                                                 [ 'code' => 'mainpage', 'text' => self::text( $mainpage ), 'module' => 'string', $C => 'text' ],
 176                                                 $I => 'warning',
 177                                         ],
 178                                 ],
 179                                 [
 180                                         'errors' => [
 181                                                 [ 'code' => 'overriddenCode', 'text' => self::text( $edithelp ),
 182                                                         'data' => $overriddenData, 'module' => 'errWithData', $C => 'text' ],
 183                                                 $I => 'error',
 184                                         ],
 185                                         'warnings' => [
 186                                                 [ 'code' => 'mainpage', 'text' => self::text( $mainpage ), 'module' => 'foo', $C => 'text' ],
 187                                                 [ 'code' => 'parentheses', 'text' => self::text( $parens ), 'module' => 'foo', $C => 'text' ],
 188                                                 [ 'code' => 'copyright', 'text' => self::text( $copyright ),
 189                                                         'module' => 'message', $C => 'text' ],
 190                                                 [ 'code' => 'overriddenCode', 'text' => self::text( $disclaimers ),
 191                                                         'data' => $overriddenData, 'module' => 'messageWithData', $C => 'text' ],
 192                                                 $I => 'warning',
 193                                         ],
 194                                 ],
 195                                 [
 196                                         'errors' => [
 197                                                 [ 'code' => 'aboutpage', 'text' => self::text( $aboutpage ),
 198                                                         'module' => 'status', $C => 'text' ],
 199                                                 [ 'code' => 'brackets', 'text' => self::text( $brackets ), 'module' => 'status', $C => 'text' ],
 200                                                 $I => 'error',
 201                                         ],
 202                                         'warnings' => [
 203                                                 [ 'code' => 'mainpage', 'text' => self::text( $mainpage ), 'module' => 'status', $C => 'text' ],
 204                                                 [ 'code' => 'parentheses', 'text' => self::text( $parens ),
 205                                                         'module' => 'status', $C => 'text' ],
 206                                                 [ 'code' => 'copyright', 'text' => self::text( $copyright ),
 207                                                         'module' => 'status', $C => 'text' ],
 208                                                 [ 'code' => 'overriddenCode', 'text' => self::text( $disclaimers ),
 209                                                         'data' => $overriddenData, 'module' => 'status', $C => 'text' ],
 210                                                 $I => 'warning',
 211                                         ],
 212                                 ],
 213                         ],
 214                         'one' => [ 'plaintext' ] + $tmp, // For these messages, plaintext and wikitext are the same
 215                         'two' => [ 'html', 'en', true,
 216                                 [
 217                                         'errors' => [
 218                                                 [ 'code' => 'aboutpage', 'html' => self::html( $aboutpage ), 'module' => 'err', $C => 'html' ],
 219                                                 $I => 'error',
 220                                         ],
 221                                         'warnings' => [
 222                                                 [ 'code' => 'mainpage', 'html' => self::html( $mainpage ), 'module' => 'string', $C => 'html' ],
 223                                                 $I => 'warning',
 224                                         ],
 225                                 ],
 226                                 [
 227                                         'errors' => [
 228                                                 [ 'code' => 'overriddenCode', 'html' => self::html( $edithelp ),
 229                                                         'data' => $overriddenData, 'module' => 'errWithData', $C => 'html' ],
 230                                                 $I => 'error',
 231                                         ],
 232                                         'warnings' => [
 233                                                 [ 'code' => 'mainpage', 'html' => self::html( $mainpage ), 'module' => 'foo', $C => 'html' ],
 234                                                 [ 'code' => 'parentheses', 'html' => self::html( $parens ), 'module' => 'foo', $C => 'html' ],
 235                                                 [ 'code' => 'copyright', 'html' => self::html( $copyright ),
 236                                                         'module' => 'message', $C => 'html' ],
 237                                                 [ 'code' => 'overriddenCode', 'html' => self::html( $disclaimers ),
 238                                                         'data' => $overriddenData, 'module' => 'messageWithData', $C => 'html' ],
 239                                                 $I => 'warning',
 240                                         ],
 241                                 ],
 242                                 [
 243                                         'errors' => [
 244                                                 [ 'code' => 'aboutpage', 'html' => self::html( $aboutpage ),
 245                                                         'module' => 'status', $C => 'html' ],
 246                                                 [ 'code' => 'brackets', 'html' => self::html( $brackets ), 'module' => 'status', $C => 'html' ],
 247                                                 $I => 'error',
 248                                         ],
 249                                         'warnings' => [
 250                                                 [ 'code' => 'mainpage', 'html' => self::html( $mainpage ), 'module' => 'status', $C => 'html' ],
 251                                                 [ 'code' => 'parentheses', 'html' => self::html( $parens ),
 252                                                         'module' => 'status', $C => 'html' ],
 253                                                 [ 'code' => 'copyright', 'html' => self::html( $copyright ),
 254                                                         'module' => 'status', $C => 'html' ],
 255                                                 [ 'code' => 'overriddenCode', 'html' => self::html( $disclaimers ),
 256                                                         'data' => $overriddenData, 'module' => 'status', $C => 'html' ],
 257                                                 $I => 'warning',
 258                                         ],
 259                                 ],
 260                         ],
 261                         'three' => [ 'raw', 'fr', true,
 262                                 [
 263                                         'errors' => [
 264                                                 [
 265                                                         'code' => 'aboutpage',
 266                                                         'key' => 'aboutpage',
 267                                                         'params' => [ $I => 'param' ],
 268                                                         'module' => 'err',
 269                                                 ],
 270                                                 $I => 'error',
 271                                         ],
 272                                         'warnings' => [
 273                                                 [
 274                                                         'code' => 'mainpage',
 275                                                         'key' => 'mainpage',
 276                                                         'params' => [ $I => 'param' ],
 277                                                         'module' => 'string',
 278                                                 ],
 279                                                 $I => 'warning',
 280                                         ],
 281                                 ],
 282                                 [
 283                                         'errors' => [
 284                                                 [
 285                                                         'code' => 'overriddenCode',
 286                                                         'key' => 'edithelp',
 287                                                         'params' => [ $I => 'param' ],
 288                                                         'data' => $overriddenData,
 289                                                         'module' => 'errWithData',
 290                                                 ],
 291                                                 $I => 'error',
 292                                         ],
 293                                         'warnings' => [
 294                                                 [
 295                                                         'code' => 'mainpage',
 296                                                         'key' => 'mainpage',
 297                                                         'params' => [ $I => 'param' ],
 298                                                         'module' => 'foo',
 299                                                 ],
 300                                                 [
 301                                                         'code' => 'parentheses',
 302                                                         'key' => 'parentheses',
 303                                                         'params' => [ 'foobar', $I => 'param' ],
 304                                                         'module' => 'foo',
 305                                                 ],
 306                                                 [
 307                                                         'code' => 'copyright',
 308                                                         'key' => 'copyright',
 309                                                         'params' => [ $I => 'param' ],
 310                                                         'module' => 'message',
 311                                                 ],
 312                                                 [
 313                                                         'code' => 'overriddenCode',
 314                                                         'key' => 'disclaimers',
 315                                                         'params' => [ $I => 'param' ],
 316                                                         'data' => $overriddenData,
 317                                                         'module' => 'messageWithData',
 318                                                 ],
 319                                                 $I => 'warning',
 320                                         ],
 321                                 ],
 322                                 [
 323                                         'errors' => [
 324                                                 [
 325                                                         'code' => 'aboutpage',
 326                                                         'key' => 'aboutpage',
 327                                                         'params' => [ $I => 'param' ],
 328                                                         'module' => 'status',
 329                                                 ],
 330                                                 [
 331                                                         'code' => 'brackets',
 332                                                         'key' => 'brackets',
 333                                                         'params' => [ 'foobar', $I => 'param' ],
 334                                                         'module' => 'status',
 335                                                 ],
 336                                                 $I => 'error',
 337                                         ],
 338                                         'warnings' => [
 339                                                 [
 340                                                         'code' => 'mainpage',
 341                                                         'key' => 'mainpage',
 342                                                         'params' => [ $I => 'param' ],
 343                                                         'module' => 'status',
 344                                                 ],
 345                                                 [
 346                                                         'code' => 'parentheses',
 347                                                         'key' => 'parentheses',
 348                                                         'params' => [ 'foobar', $I => 'param' ],
 349                                                         'module' => 'status',
 350                                                 ],
 351                                                 [
 352                                                         'code' => 'copyright',
 353                                                         'key' => 'copyright',
 354                                                         'params' => [ $I => 'param' ],
 355                                                         'module' => 'status',
 356                                                 ],
 357                                                 [
 358                                                         'code' => 'overriddenCode',
 359                                                         'key' => 'disclaimers',
 360                                                         'params' => [ $I => 'param' ],
 361                                                         'data' => $overriddenData,
 362                                                         'module' => 'status',
 363                                                 ],
 364                                                 $I => 'warning',
 365                                         ],
 366                                 ],
 367                         ],
 368                         'four' => [ 'none', 'fr', true,
 369                                 [
 370                                         'errors' => [
 371                                                 [ 'code' => 'aboutpage', 'module' => 'err' ],
 372                                                 $I => 'error',
 373                                         ],
 374                                         'warnings' => [
 375                                                 [ 'code' => 'mainpage', 'module' => 'string' ],
 376                                                 $I => 'warning',
 377                                         ],
 378                                 ],
 379                                 [
 380                                         'errors' => [
 381                                                 [ 'code' => 'overriddenCode', 'data' => $overriddenData,
 382                                                         'module' => 'errWithData' ],
 383                                                 $I => 'error',
 384                                         ],
 385                                         'warnings' => [
 386                                                 [ 'code' => 'mainpage', 'module' => 'foo' ],
 387                                                 [ 'code' => 'parentheses', 'module' => 'foo' ],
 388                                                 [ 'code' => 'copyright', 'module' => 'message' ],
 389                                                 [ 'code' => 'overriddenCode', 'data' => $overriddenData,
 390                                                         'module' => 'messageWithData' ],
 391                                                 $I => 'warning',
 392                                         ],
 393                                 ],
 394                                 [
 395                                         'errors' => [
 396                                                 [ 'code' => 'aboutpage', 'module' => 'status' ],
 397                                                 [ 'code' => 'brackets', 'module' => 'status' ],
 398                                                 $I => 'error',
 399                                         ],
 400                                         'warnings' => [
 401                                                 [ 'code' => 'mainpage', 'module' => 'status' ],
 402                                                 [ 'code' => 'parentheses', 'module' => 'status' ],
 403                                                 [ 'code' => 'copyright', 'module' => 'status' ],
 404                                                 [ 'code' => 'overriddenCode', 'data' => $overriddenData, 'module' => 'status' ],
 405                                                 $I => 'warning',
 406                                         ],
 407                                 ],
 408                         ],
 409                 ];
 410         }
 411
 412         /**
 413          * @covers \MediaWiki\Api\ApiErrorFormatter_BackCompat
 414          */
 415         public function testErrorFormatterBC() {
 416                 $aboutpage = wfMessage( 'aboutpage' );
 417                 $mainpage = wfMessage( 'mainpage' );
 418                 $parens = wfMessage( 'parentheses', 'foobar' );
 419                 $copyright = wfMessage( 'copyright' );
 420                 $disclaimers = wfMessage( 'disclaimers' );
 421                 $edithelp = wfMessage( 'edithelp' );
 422
 423                 $result = new ApiResult( 8_388_608 );
 424                 $formatter = new ApiErrorFormatter_BackCompat( $result );
 425
 426                 $this->assertSame( 'en', $formatter->getLanguage()->getCode() );
 427                 $this->assertSame( 'bc', $formatter->getFormat() );
 428
 429                 $this->assertSame( [], $formatter->arrayFromStatus( Status::newGood() ) );
 430
 431                 $formatter->addWarning( 'string', 'mainpage' );
 432                 $formatter->addWarning( 'raw',
 433                         new RawMessage( 'Blah <kbd>kbd</kbd> <b>&lt;X&gt;</b> &#x1f61e;' )
 434                 );
 435                 $formatter->addError( 'err', 'aboutpage' );
 436                 $this->assertSame( [
 437                         'error' => [
 438                                 'code' => 'aboutpage',
 439                                 'info' => $aboutpage->useDatabase( false )->plain(),
 440                         ],
 441                         'warnings' => [
 442                                 'raw' => [
 443                                         'warnings' => 'Blah "kbd" <X> 😞',
 444                                         ApiResult::META_CONTENT => 'warnings',
 445                                 ],
 446                                 'string' => [
 447                                         'warnings' => $mainpage->useDatabase( false )->plain(),
 448                                         ApiResult::META_CONTENT => 'warnings',
 449                                 ],
 450                         ],
 451                         ApiResult::META_TYPE => 'assoc',
 452                 ], $result->getResultData(), 'Simple test' );
 453
 454                 $result->reset();
 455                 $formatter->addWarning( 'foo', 'mainpage' );
 456                 $formatter->addWarning( 'foo', 'mainpage' );
 457                 $formatter->addWarning( 'xxx+foo', [ 'parentheses', 'foobar' ] );
 458                 $msg1 = wfMessage( 'copyright' );
 459                 $formatter->addWarning( 'message', $msg1 );
 460                 $msg2 = new ApiMessage( 'disclaimers', 'overriddenCode', [ 'overriddenData' => true ] );
 461                 $formatter->addWarning( 'messageWithData', $msg2 );
 462                 $msg3 = new ApiMessage( 'edithelp', 'overriddenCode', [ 'overriddenData' => true ] );
 463                 $formatter->addError( 'errWithData', $msg3 );
 464                 $formatter->addWarning( null, 'mainpage' );
 465                 $this->assertSame( [
 466                         'error' => [
 467                                 'code' => 'overriddenCode',
 468                                 'info' => $edithelp->useDatabase( false )->plain(),
 469                                 'overriddenData' => true,
 470                         ],
 471                         'warnings' => [
 472                                 'unknown' => [
 473                                         'warnings' => $mainpage->useDatabase( false )->plain(),
 474                                         ApiResult::META_CONTENT => 'warnings',
 475                                 ],
 476                                 'messageWithData' => [
 477                                         'warnings' => $disclaimers->useDatabase( false )->plain(),
 478                                         ApiResult::META_CONTENT => 'warnings',
 479                                 ],
 480                                 'message' => [
 481                                         'warnings' => $copyright->useDatabase( false )->plain(),
 482                                         ApiResult::META_CONTENT => 'warnings',
 483                                 ],
 484                                 'foo' => [
 485                                         'warnings' => $mainpage->useDatabase( false )->plain()
 486                                                 . "\n" . $parens->useDatabase( false )->plain(),
 487                                         ApiResult::META_CONTENT => 'warnings',
 488                                 ],
 489                         ],
 490                         ApiResult::META_TYPE => 'assoc',
 491                 ], $result->getResultData(), 'Complex test' );
 492
 493                 $this->assertSame(
 494                         [
 495                                 'code' => 'copyright',
 496                                 'info' => $copyright->useDatabase( false )->plain(),
 497                         ],
 498                         $formatter->formatMessage( $msg1 )
 499                 );
 500                 $this->assertSame(
 501                         [
 502                                 'code' => 'overriddenCode',
 503                                 'info' => $disclaimers->useDatabase( false )->plain(),
 504                                 'overriddenData' => true,
 505                         ],
 506                         $formatter->formatMessage( $msg2 )
 507                 );
 508                 $this->assertSame(
 509                         [
 510                                 'code' => 'overriddenCode',
 511                                 'info' => $edithelp->useDatabase( false )->plain(),
 512                                 'overriddenData' => true,
 513                         ],
 514                         $formatter->formatMessage( $msg3 )
 515                 );
 516
 517                 $result->reset();
 518                 $status = Status::newGood();
 519                 $status->warning( 'mainpage' );
 520                 $status->warning( 'parentheses', 'foobar' );
 521                 $status->warning( $msg1 );
 522                 $status->warning( $msg2 );
 523                 $status->error( 'aboutpage' );
 524                 $status->error( 'brackets', 'foobar' );
 525                 $formatter->addMessagesFromStatus( 'status', $status );
 526                 $this->assertSame( [
 527                         'error' => [
 528                                 'code' => 'aboutpage',
 529                                 'info' => $aboutpage->useDatabase( false )->plain(),
 530                         ],
 531                         'warnings' => [
 532                                 'status' => [
 533                                         'warnings' => $mainpage->useDatabase( false )->plain()
 534                                                 . "\n" . $parens->useDatabase( false )->plain()
 535                                                 . "\n" . $copyright->useDatabase( false )->plain()
 536                                                 . "\n" . $disclaimers->useDatabase( false )->plain(),
 537                                         ApiResult::META_CONTENT => 'warnings',
 538                                 ],
 539                         ],
 540                         ApiResult::META_TYPE => 'assoc',
 541                 ], $result->getResultData(), 'Status test' );
 542
 543                 $I = ApiResult::META_INDEXED_TAG_NAME;
 544                 $this->assertSame(
 545                         [
 546                                 [
 547                                         'message' => 'aboutpage',
 548                                         'params' => [ $I => 'param' ],
 549                                         'code' => 'aboutpage',
 550                                         'type' => 'error',
 551                                 ],
 552                                 [
 553                                         'message' => 'brackets',
 554                                         'params' => [ 'foobar', $I => 'param' ],
 555                                         'code' => 'brackets',
 556                                         'type' => 'error',
 557                                 ],
 558                                 $I => 'error',
 559                         ],
 560                         $formatter->arrayFromStatus( $status, 'error' ),
 561                         'arrayFromStatus test for error'
 562                 );
 563                 $this->assertSame(
 564                         [
 565                                 [
 566                                         'message' => 'mainpage',
 567                                         'params' => [ $I => 'param' ],
 568                                         'code' => 'mainpage',
 569                                         'type' => 'warning',
 570                                 ],
 571                                 [
 572                                         'message' => 'parentheses',
 573                                         'params' => [ 'foobar', $I => 'param' ],
 574                                         'code' => 'parentheses',
 575                                         'type' => 'warning',
 576                                 ],
 577                                 [
 578                                         'message' => 'copyright',
 579                                         'params' => [ $I => 'param' ],
 580                                         'code' => 'copyright',
 581                                         'type' => 'warning',
 582                                 ],
 583                                 [
 584                                         'message' => 'disclaimers',
 585                                         'params' => [ $I => 'param' ],
 586                                         'code' => 'overriddenCode',
 587                                         'type' => 'warning',
 588                                 ],
 589                                 $I => 'warning',
 590                         ],
 591                         $formatter->arrayFromStatus( $status, 'warning' ),
 592                         'arrayFromStatus test for warning'
 593                 );
 594
 595                 $result->reset();
 596                 $result->addValue( null, 'error', [ 'bogus' ] );
 597                 $formatter->addError( 'err', 'aboutpage' );
 598                 $this->assertSame( [
 599                         'error' => [
 600                                 'code' => 'aboutpage',
 601                                 'info' => $aboutpage->useDatabase( false )->plain(),
 602                         ],
 603                         ApiResult::META_TYPE => 'assoc',
 604                 ], $result->getResultData(), 'Overwrites bogus "error" value with real error' );
 605         }
 606
 607         /**
 608          * @dataProvider provideGetMessageFromException
 609          * @covers \MediaWiki\Api\ApiErrorFormatter::getMessageFromException
 610          * @covers \MediaWiki\Api\ApiErrorFormatter::formatException
 611          * @param Exception $exception
 612          * @param array $options
 613          * @param array $expect
 614          */
 615         public function testGetMessageFromException( $exception, $options, $expect ) {
 616                 $result = new ApiResult( 8_388_608 );
 617                 $formatter = new ApiErrorFormatter( $result,
 618                         $this->getServiceContainer()->getLanguageFactory()->getLanguage( 'en' ), 'html',
 619                         false );
 620
 621                 $msg = $formatter->getMessageFromException( $exception, $options );
 622                 $this->assertInstanceOf( Message::class, $msg );
 623                 $this->assertInstanceOf( IApiMessage::class, $msg );
 624                 $this->assertSame( $expect, [
 625                         'text' => $msg->parse(),
 626                         'code' => $msg->getApiCode(),
 627                         'data' => $msg->getApiData(),
 628                 ] );
 629
 630                 $expectFormatted = $formatter->formatMessage( $msg );
 631                 $formatted = $formatter->formatException( $exception, $options );
 632                 $this->assertSame( $expectFormatted, $formatted );
 633         }
 634
 635         /**
 636          * @dataProvider provideGetMessageFromException
 637          * @covers \MediaWiki\Api\ApiErrorFormatter_BackCompat::formatException
 638          * @param Exception $exception
 639          * @param array $options
 640          * @param array $expect
 641          */
 642         public function testGetMessageFromException_BC( $exception, $options, $expect ) {
 643                 $result = new ApiResult( 8_388_608 );
 644                 $formatter = new ApiErrorFormatter_BackCompat( $result );
 645
 646                 $msg = $formatter->getMessageFromException( $exception, $options );
 647                 $this->assertInstanceOf( Message::class, $msg );
 648                 $this->assertInstanceOf( IApiMessage::class, $msg );
 649                 $this->assertSame( $expect, [
 650                         'text' => $msg->parse(),
 651                         'code' => $msg->getApiCode(),
 652                         'data' => $msg->getApiData(),
 653                 ] );
 654
 655                 $expectFormatted = $formatter->formatMessage( $msg );
 656                 $formatted = $formatter->formatException( $exception, $options );
 657                 $this->assertSame( $expectFormatted, $formatted );
 658                 $formatted = $formatter->formatException( $exception, $options + [ 'bc' => true ] );
 659                 $this->assertSame( $expectFormatted['info'], $formatted );
 660         }
 661
 662         public static function provideGetMessageFromException() {
 663                 return [
 664                         'Normal exception' => [
 665                                 new RuntimeException( '<b>Something broke!</b>' ),
 666                                 [],
 667                                 [
 668                                         'text' => '&#60;b&#62;Something broke!&#60;/b&#62;',
 669                                         'code' => 'internal_api_error_RuntimeException',
 670                                         'data' => [
 671                                                 'errorclass' => 'RuntimeException',
 672                                         ],
 673                                 ]
 674                         ],
 675                         'Normal exception, wrapped' => [
 676                                 new RuntimeException( '<b>Something broke!</b>' ),
 677                                 [ 'wrap' => 'parentheses', 'code' => 'some-code', 'data' => [ 'foo' => 'bar', 'baz' => 42 ] ],
 678                                 [
 679                                         'text' => '(&#60;b&#62;Something broke!&#60;/b&#62;)',
 680                                         'code' => 'some-code',
 681                                         'data' => [ 'foo' => 'bar', 'baz' => 42 ],
 682                                 ]
 683                         ],
 684                         'LocalizedException' => [
 685                                 new LocalizedException( [ 'returnto', '<b>FooBar</b>' ] ),
 686                                 [],
 687                                 [
 688                                         'text' => 'Return to <b>FooBar</b>.',
 689                                         'code' => 'returnto',
 690                                         'data' => [],
 691                                 ]
 692                         ],
 693                         'LocalizedException, wrapped' => [
 694                                 new LocalizedException( [ 'returnto', '<b>FooBar</b>' ] ),
 695                                 [ 'wrap' => 'parentheses', 'code' => 'some-code', 'data' => [ 'foo' => 'bar', 'baz' => 42 ] ],
 696                                 [
 697                                         'text' => 'Return to <b>FooBar</b>.',
 698                                         'code' => 'some-code',
 699                                         'data' => [ 'foo' => 'bar', 'baz' => 42 ],
 700                                 ]
 701                         ],
 702                 ];
 703         }
 704
 705         /**
 706          * @covers \MediaWiki\Api\ApiErrorFormatter::addMessagesFromStatus
 707          * @covers \MediaWiki\Api\ApiErrorFormatter::addWarningOrError
 708          * @covers \MediaWiki\Api\ApiErrorFormatter::formatMessageInternal
 709          */
 710         public function testAddMessagesFromStatus_filter() {
 711                 $result = new ApiResult( 8_388_608 );
 712                 $formatter = new ApiErrorFormatter( $result,
 713                         $this->getServiceContainer()->getLanguageFactory()->getLanguage( 'qqx' ),
 714                         'plaintext', false );
 715
 716                 $status = Status::newGood();
 717                 $status->warning( 'mainpage' );
 718                 $status->warning( 'parentheses', 'foobar' );
 719                 $status->warning( wfMessage( 'mainpage' ) );
 720                 $status->error( 'mainpage' );
 721                 $status->error( 'parentheses', 'foobaz' );
 722                 $formatter->addMessagesFromStatus( 'status', $status, [ 'warning', 'error' ], [ 'mainpage' ] );
 723                 $this->assertSame( [
 724                         'errors' => [
 725                                 [
 726                                         'code' => 'parentheses',
 727                                         'text' => '(parentheses: foobaz)',
 728                                         'module' => 'status',
 729                                         ApiResult::META_CONTENT => 'text',
 730                                 ],
 731                                 ApiResult::META_INDEXED_TAG_NAME => 'error',
 732                         ],
 733                         'warnings' => [
 734                                 [
 735                                         'code' => 'parentheses',
 736                                         'text' => '(parentheses: foobar)',
 737                                         'module' => 'status',
 738                                         ApiResult::META_CONTENT => 'text',
 739                                 ],
 740                                 ApiResult::META_INDEXED_TAG_NAME => 'warning',
 741                         ],
 742                         ApiResult::META_TYPE => 'assoc',
 743                 ], $result->getResultData() );
 744         }
 745
 746         /**
 747          * @dataProvider provideIsValidApiCode
 748          * @covers \MediaWiki\Api\ApiErrorFormatter::isValidApiCode
 749          * @param string $code
 750          * @param bool $expect
 751          */
 752         public function testIsValidApiCode( $code, $expect ) {
 753                 $this->assertSame( $expect, ApiErrorFormatter::isValidApiCode( $code ) );
 754         }
 755
 756         public static function provideIsValidApiCode() {
 757                 return [
 758                         [ 'foo-bar_Baz123', true ],
 759                         [ 'foo bar', false ],
 760                         [ 'foo\\bar', false ],
 761                         [ 'internal_api_error_foo\\bar baz', true ],
 762                 ];
 763         }
 764
 765 }