tests/phpunit/includes/XmlTest.php

   1 <?php
   2
   3 /**
   4  * @group Xml
   5  */
   6 class XmlTest extends MediaWikiTestCase {
   7
   8         protected function setUp() {
   9                 parent::setUp();
  10
  11                 $langObj = Language::factory( 'en' );
  12                 $langObj->setNamespaces( [
  13                         -2 => 'Media',
  14                         -1 => 'Special',
  15                         0 => '',
  16                         1 => 'Talk',
  17                         2 => 'User',
  18                         3 => 'User_talk',
  19                         4 => 'MyWiki',
  20                         5 => 'MyWiki_Talk',
  21                         6 => 'File',
  22                         7 => 'File_talk',
  23                         8 => 'MediaWiki',
  24                         9 => 'MediaWiki_talk',
  25                         10 => 'Template',
  26                         11 => 'Template_talk',
  27                         100 => 'Custom',
  28                         101 => 'Custom_talk',
  29                 ] );
  30
  31                 $this->setMwGlobals( [
  32                         'wgLang' => $langObj,
  33                         'wgUseMediaWikiUIEverywhere' => false,
  34                 ] );
  35         }
  36
  37         protected function tearDown() {
  38                 Language::factory( 'en' )->resetNamespaces();
  39                 parent::tearDown();
  40         }
  41
  42         /**
  43          * @covers Xml::expandAttributes
  44          */
  45         public function testExpandAttributes() {
  46                 $this->assertNull( Xml::expandAttributes( null ),
  47                         'Converting a null list of attributes'
  48                 );
  49                 $this->assertEquals( '', Xml::expandAttributes( [] ),
  50                         'Converting an empty list of attributes'
  51                 );
  52         }
  53
  54         /**
  55          * @covers Xml::expandAttributes
  56          */
  57         public function testExpandAttributesException() {
  58                 $this->setExpectedException( MWException::class );
  59                 Xml::expandAttributes( 'string' );
  60         }
  61
  62         /**
  63          * @covers Xml::element
  64          */
  65         public function testElementOpen() {
  66                 $this->assertEquals(
  67                         '<element>',
  68                         Xml::element( 'element', null, null ),
  69                         'Opening element with no attributes'
  70                 );
  71         }
  72
  73         /**
  74          * @covers Xml::element
  75          */
  76         public function testElementEmpty() {
  77                 $this->assertEquals(
  78                         '<element />',
  79                         Xml::element( 'element', null, '' ),
  80                         'Terminated empty element'
  81                 );
  82         }
  83
  84         /**
  85          * @covers Xml::input
  86          */
  87         public function testElementInputCanHaveAValueOfZero() {
  88                 $this->assertEquals(
  89                         '<input name="name" value="0" />',
  90                         Xml::input( 'name', false, 0 ),
  91                         'Input with a value of 0 (T25797)'
  92                 );
  93         }
  94
  95         /**
  96          * @covers Xml::element
  97          */
  98         public function testElementEscaping() {
  99                 $this->assertEquals(
 100                         '<element>hello &lt;there&gt; you &amp; you</element>',
 101                         Xml::element( 'element', null, 'hello <there> you & you' ),
 102                         'Element with no attributes and content that needs escaping'
 103                 );
 104         }
 105
 106         /**
 107          * @covers Xml::escapeTagsOnly
 108          */
 109         public function testEscapeTagsOnly() {
 110                 $this->assertEquals( '&quot;&gt;&lt;', Xml::escapeTagsOnly( '"><' ),
 111                         'replace " > and < with their HTML entitites'
 112                 );
 113         }
 114
 115         /**
 116          * @covers Xml::element
 117          */
 118         public function testElementAttributes() {
 119                 $this->assertEquals(
 120                         '<element key="value" <>="&lt;&gt;">',
 121                         Xml::element( 'element', [ 'key' => 'value', '<>' => '<>' ], null ),
 122                         'Element attributes, keys are not escaped'
 123                 );
 124         }
 125
 126         /**
 127          * @covers Xml::openElement
 128          */
 129         public function testOpenElement() {
 130                 $this->assertEquals(
 131                         '<element k="v">',
 132                         Xml::openElement( 'element', [ 'k' => 'v' ] ),
 133                         'openElement() shortcut'
 134                 );
 135         }
 136
 137         /**
 138          * @covers Xml::closeElement
 139          */
 140         public function testCloseElement() {
 141                 $this->assertEquals( '</element>', Xml::closeElement( 'element' ), 'closeElement() shortcut' );
 142         }
 143
 144         public function provideMonthSelector() {
 145                 global $wgLang;
 146
 147                 $header = '<select name="month" id="month" class="mw-month-selector">';
 148                 $header2 = '<select name="month" id="monthSelector" class="mw-month-selector">';
 149                 $monthsString = '';
 150                 for ( $i = 1; $i < 13; $i++ ) {
 151                         $monthName = $wgLang->getMonthName( $i );
 152                         $monthsString .= "<option value=\"{$i}\">{$monthName}</option>";
 153                         if ( $i !== 12 ) {
 154                                 $monthsString .= "\n";
 155                         }
 156                 }
 157                 $monthsString2 = str_replace(
 158                         '<option value="12">December</option>',
 159                         '<option value="12" selected="">December</option>',
 160                         $monthsString
 161                 );
 162                 $end = '</select>';
 163
 164                 $allMonths = "<option value=\"AllMonths\">all</option>\n";
 165                 return [
 166                         [ $header . $monthsString . $end, '', null, 'month' ],
 167                         [ $header . $monthsString2 . $end, 12, null, 'month' ],
 168                         [ $header2 . $monthsString . $end, '', null, 'monthSelector' ],
 169                         [ $header . $allMonths . $monthsString . $end, '', 'AllMonths', 'month' ],
 170
 171                 ];
 172         }
 173
 174         /**
 175          * @covers Xml::monthSelector
 176          * @dataProvider provideMonthSelector
 177          */
 178         public function testMonthSelector( $expected, $selected, $allmonths, $id ) {
 179                 $this->assertEquals(
 180                         $expected,
 181                         Xml::monthSelector( $selected, $allmonths, $id )
 182                 );
 183         }
 184
 185         /**
 186          * @covers Xml::span
 187          */
 188         public function testSpan() {
 189                 $this->assertEquals(
 190                         '<span class="foo" id="testSpan">element</span>',
 191                         Xml::span( 'element', 'foo', [ 'id' => 'testSpan' ] )
 192                 );
 193         }
 194
 195         /**
 196          * @covers Xml::dateMenu
 197          */
 198         public function testDateMenu() {
 199                 $curYear = intval( gmdate( 'Y' ) );
 200                 $prevYear = $curYear - 1;
 201
 202                 $curMonth = intval( gmdate( 'n' ) );
 203
 204                 $nextMonth = $curMonth + 1;
 205                 if ( $nextMonth == 13 ) {
 206                         $nextMonth = 1;
 207                 }
 208
 209                 $this->assertEquals(
 210                         '<label for="year">From year (and earlier):</label> ' .
 211                                 '<input id="year" maxlength="4" size="7" type="number" value="2011" name="year"/> ' .
 212                                 '<label for="month">From month (and earlier):</label> ' .
 213                                 '<select name="month" id="month" class="mw-month-selector">' .
 214                                 '<option value="-1">all</option>' . "\n" .
 215                                 '<option value="1">January</option>' . "\n" .
 216                                 '<option value="2" selected="">February</option>' . "\n" .
 217                                 '<option value="3">March</option>' . "\n" .
 218                                 '<option value="4">April</option>' . "\n" .
 219                                 '<option value="5">May</option>' . "\n" .
 220                                 '<option value="6">June</option>' . "\n" .
 221                                 '<option value="7">July</option>' . "\n" .
 222                                 '<option value="8">August</option>' . "\n" .
 223                                 '<option value="9">September</option>' . "\n" .
 224                                 '<option value="10">October</option>' . "\n" .
 225                                 '<option value="11">November</option>' . "\n" .
 226                                 '<option value="12">December</option></select>',
 227                         Xml::dateMenu( 2011, 02 ),
 228                         "Date menu for february 2011"
 229                 );
 230                 $this->assertEquals(
 231                         '<label for="year">From year (and earlier):</label> ' .
 232                                 '<input id="year" maxlength="4" size="7" type="number" value="2011" name="year"/> ' .
 233                                 '<label for="month">From month (and earlier):</label> ' .
 234                                 '<select name="month" id="month" class="mw-month-selector">' .
 235                                 '<option value="-1">all</option>' . "\n" .
 236                                 '<option value="1">January</option>' . "\n" .
 237                                 '<option value="2">February</option>' . "\n" .
 238                                 '<option value="3">March</option>' . "\n" .
 239                                 '<option value="4">April</option>' . "\n" .
 240                                 '<option value="5">May</option>' . "\n" .
 241                                 '<option value="6">June</option>' . "\n" .
 242                                 '<option value="7">July</option>' . "\n" .
 243                                 '<option value="8">August</option>' . "\n" .
 244                                 '<option value="9">September</option>' . "\n" .
 245                                 '<option value="10">October</option>' . "\n" .
 246                                 '<option value="11">November</option>' . "\n" .
 247                                 '<option value="12">December</option></select>',
 248                         Xml::dateMenu( 2011, -1 ),
 249                         "Date menu with negative month for 'All'"
 250                 );
 251                 $this->assertEquals(
 252                         Xml::dateMenu( $curYear, $curMonth ),
 253                         Xml::dateMenu( '', $curMonth ),
 254                         "Date menu year is the current one when not specified"
 255                 );
 256
 257                 $wantedYear = $nextMonth == 1 ? $curYear : $prevYear;
 258                 $this->assertEquals(
 259                         Xml::dateMenu( $wantedYear, $nextMonth ),
 260                         Xml::dateMenu( '', $nextMonth ),
 261                         "Date menu next month is 11 months ago"
 262                 );
 263
 264                 $this->assertEquals(
 265                         '<label for="year">From year (and earlier):</label> ' .
 266                                 '<input id="year" maxlength="4" size="7" type="number" name="year"/> ' .
 267                                 '<label for="month">From month (and earlier):</label> ' .
 268                                 '<select name="month" id="month" class="mw-month-selector">' .
 269                                 '<option value="-1">all</option>' . "\n" .
 270                                 '<option value="1">January</option>' . "\n" .
 271                                 '<option value="2">February</option>' . "\n" .
 272                                 '<option value="3">March</option>' . "\n" .
 273                                 '<option value="4">April</option>' . "\n" .
 274                                 '<option value="5">May</option>' . "\n" .
 275                                 '<option value="6">June</option>' . "\n" .
 276                                 '<option value="7">July</option>' . "\n" .
 277                                 '<option value="8">August</option>' . "\n" .
 278                                 '<option value="9">September</option>' . "\n" .
 279                                 '<option value="10">October</option>' . "\n" .
 280                                 '<option value="11">November</option>' . "\n" .
 281                                 '<option value="12">December</option></select>',
 282                         Xml::dateMenu( '', '' ),
 283                         "Date menu with neither year or month"
 284                 );
 285         }
 286
 287         /**
 288          * @covers Xml::textarea
 289          */
 290         public function testTextareaNoContent() {
 291                 $this->assertEquals(
 292                         '<textarea name="name" id="name" cols="40" rows="5"></textarea>',
 293                         Xml::textarea( 'name', '' ),
 294                         'textarea() with not content'
 295                 );
 296         }
 297
 298         /**
 299          * @covers Xml::textarea
 300          */
 301         public function testTextareaAttribs() {
 302                 $this->assertEquals(
 303                         '<textarea name="name" id="name" cols="20" rows="10">&lt;txt&gt;</textarea>',
 304                         Xml::textarea( 'name', '<txt>', 20, 10 ),
 305                         'textarea() with custom attribs'
 306                 );
 307         }
 308
 309         /**
 310          * @covers Xml::label
 311          */
 312         public function testLabelCreation() {
 313                 $this->assertEquals(
 314                         '<label for="id">name</label>',
 315                         Xml::label( 'name', 'id' ),
 316                         'label() with no attribs'
 317                 );
 318         }
 319
 320         /**
 321          * @covers Xml::label
 322          */
 323         public function testLabelAttributeCanOnlyBeClassOrTitle() {
 324                 $this->assertEquals(
 325                         '<label for="id">name</label>',
 326                         Xml::label( 'name', 'id', [ 'generated' => true ] ),
 327                         'label() can not be given a generated attribute'
 328                 );
 329                 $this->assertEquals(
 330                         '<label for="id" class="nice">name</label>',
 331                         Xml::label( 'name', 'id', [ 'class' => 'nice' ] ),
 332                         'label() can get a class attribute'
 333                 );
 334                 $this->assertEquals(
 335                         '<label for="id" title="nice tooltip">name</label>',
 336                         Xml::label( 'name', 'id', [ 'title' => 'nice tooltip' ] ),
 337                         'label() can get a title attribute'
 338                 );
 339                 $this->assertEquals(
 340                         '<label for="id" class="nice" title="nice tooltip">name</label>',
 341                         Xml::label( 'name', 'id', [
 342                                         'generated' => true,
 343                                         'class' => 'nice',
 344                                         'title' => 'nice tooltip',
 345                                         'anotherattr' => 'value',
 346                                 ]
 347                         ),
 348                         'label() skip all attributes but "class" and "title"'
 349                 );
 350         }
 351
 352         /**
 353          * @covers Xml::languageSelector
 354          */
 355         public function testLanguageSelector() {
 356                 $select = Xml::languageSelector( 'en', true, null,
 357                         [ 'id' => 'testlang' ], wfMessage( 'yourlanguage' ) );
 358                 $this->assertEquals(
 359                         '<label for="testlang">Language:</label>',
 360                         $select[0]
 361                 );
 362         }
 363
 364         /**
 365          * @covers Xml::encodeJsVar
 366          */
 367         public function testEncodeJsVarBoolean() {
 368                 $this->assertEquals(
 369                         'true',
 370                         Xml::encodeJsVar( true ),
 371                         'encodeJsVar() with boolean'
 372                 );
 373         }
 374
 375         /**
 376          * @covers Xml::encodeJsVar
 377          */
 378         public function testEncodeJsVarNull() {
 379                 $this->assertEquals(
 380                         'null',
 381                         Xml::encodeJsVar( null ),
 382                         'encodeJsVar() with null'
 383                 );
 384         }
 385
 386         /**
 387          * @covers Xml::encodeJsVar
 388          */
 389         public function testEncodeJsVarArray() {
 390                 $this->assertEquals(
 391                         '["a",1]',
 392                         Xml::encodeJsVar( [ 'a', 1 ] ),
 393                         'encodeJsVar() with array'
 394                 );
 395                 $this->assertEquals(
 396                         '{"a":"a","b":1}',
 397                         Xml::encodeJsVar( [ 'a' => 'a', 'b' => 1 ] ),
 398                         'encodeJsVar() with associative array'
 399                 );
 400         }
 401
 402         /**
 403          * @covers Xml::encodeJsVar
 404          */
 405         public function testEncodeJsVarObject() {
 406                 $this->assertEquals(
 407                         '{"a":"a","b":1}',
 408                         Xml::encodeJsVar( (object)[ 'a' => 'a', 'b' => 1 ] ),
 409                         'encodeJsVar() with object'
 410                 );
 411         }
 412
 413         /**
 414          * @covers Xml::encodeJsVar
 415          */
 416         public function testEncodeJsVarInt() {
 417                 $this->assertEquals(
 418                         '123456',
 419                         Xml::encodeJsVar( 123456 ),
 420                         'encodeJsVar() with int'
 421                 );
 422         }
 423
 424         /**
 425          * @covers Xml::encodeJsVar
 426          */
 427         public function testEncodeJsVarFloat() {
 428                 $this->assertEquals(
 429                         '1.23456',
 430                         Xml::encodeJsVar( 1.23456 ),
 431                         'encodeJsVar() with float'
 432                 );
 433         }
 434
 435         /**
 436          * @covers Xml::encodeJsVar
 437          */
 438         public function testEncodeJsVarIntString() {
 439                 $this->assertEquals(
 440                         '"123456"',
 441                         Xml::encodeJsVar( '123456' ),
 442                         'encodeJsVar() with int-like string'
 443                 );
 444         }
 445
 446         /**
 447          * @covers Xml::encodeJsVar
 448          */
 449         public function testEncodeJsVarFloatString() {
 450                 $this->assertEquals(
 451                         '"1.23456"',
 452                         Xml::encodeJsVar( '1.23456' ),
 453                         'encodeJsVar() with float-like string'
 454                 );
 455         }
 456
 457         /**
 458          * @covers Xml::listDropDown
 459          */
 460         public function testListDropDown() {
 461                 $this->assertEquals(
 462                         '<select name="test-name" id="test-name" class="test-css" tabindex="2">' .
 463                                 '<option value="other">other reasons</option>' . "\n" .
 464                                 '<optgroup label="Foo">' .
 465                                 '<option value="Foo 1">Foo 1</option>' . "\n" .
 466                                 '<option value="Example" selected="">Example</option>' . "\n" .
 467                                 '</optgroup>' . "\n" .
 468                                 '<optgroup label="Bar">' .
 469                                 '<option value="Bar 1">Bar 1</option>' . "\n" .
 470                                 '</optgroup>' .
 471                                 '</select>',
 472                         Xml::listDropDown(
 473                                 // name
 474                                 'test-name',
 475                                 // source list
 476                                 "* Foo\n** Foo 1\n** Example\n* Bar\n** Bar 1",
 477                                 // other
 478                                 'other reasons',
 479                                 // selected
 480                                 'Example',
 481                                 // class
 482                                 'test-css',
 483                                 // tabindex
 484                                 2
 485                         )
 486                 );
 487         }
 488
 489         /**
 490          * @covers Xml::listDropDownOptions
 491          */
 492         public function testListDropDownOptions() {
 493                 $this->assertEquals(
 494                         [
 495                                 'other reasons' => 'other',
 496                                 'Foo' => [
 497                                         'Foo 1' => 'Foo 1',
 498                                         'Example' => 'Example',
 499                                 ],
 500                                 'Bar' => [
 501                                         'Bar 1' => 'Bar 1',
 502                                 ],
 503                         ],
 504                         Xml::listDropDownOptions(
 505                                 "* Foo\n** Foo 1\n** Example\n* Bar\n** Bar 1",
 506                                 [ 'other' => 'other reasons' ]
 507                         )
 508                 );
 509         }
 510
 511         /**
 512          * @covers Xml::listDropDownOptionsOoui
 513          */
 514         public function testListDropDownOptionsOoui() {
 515                 $this->assertEquals(
 516                         [
 517                                 [ 'data' => 'other', 'label' => 'other reasons' ],
 518                                 [ 'optgroup' => 'Foo' ],
 519                                 [ 'data' => 'Foo 1', 'label' => 'Foo 1' ],
 520                                 [ 'data' => 'Example', 'label' => 'Example' ],
 521                                 [ 'optgroup' => 'Bar' ],
 522                                 [ 'data' => 'Bar 1', 'label' => 'Bar 1' ],
 523                         ],
 524                         Xml::listDropDownOptionsOoui( [
 525                                 'other reasons' => 'other',
 526                                 'Foo' => [
 527                                         'Foo 1' => 'Foo 1',
 528                                         'Example' => 'Example',
 529                                 ],
 530                                 'Bar' => [
 531                                         'Bar 1' => 'Bar 1',
 532                                 ],
 533                         ] )
 534                 );
 535         }
 536
 537         /**
 538          * @covers Xml::fieldset
 539          */
 540         public function testFieldset() {
 541                 $this->assertEquals(
 542                         "<fieldset>\n",
 543                         Xml::fieldset(),
 544                         'Opening tag'
 545                 );
 546                 $this->assertEquals(
 547                         "<fieldset>\n",
 548                         Xml::fieldset( false ),
 549                         'Opening tag (false means no legend)'
 550                 );
 551                 $this->assertEquals(
 552                         "<fieldset>\n",
 553                         Xml::fieldset( '' ),
 554                         'Opening tag (empty string also means no legend)'
 555                 );
 556                 $this->assertEquals(
 557                         "<fieldset>\n<legend>Foo</legend>\n",
 558                         Xml::fieldset( 'Foo' ),
 559                         'Opening tag with legend'
 560                 );
 561                 $this->assertEquals(
 562                         "<fieldset>\n<legend>Foo</legend>\nBar\n</fieldset>\n",
 563                         Xml::fieldset( 'Foo', 'Bar' ),
 564                         'Entire element with legend'
 565                 );
 566                 $this->assertEquals(
 567                         "<fieldset>\n<legend>Foo</legend>\n",
 568                         Xml::fieldset( 'Foo', false ),
 569                         'Opening tag with legend (false means no content and no closing tag)'
 570                 );
 571                 $this->assertEquals(
 572                         "<fieldset>\n<legend>Foo</legend>\n\n</fieldset>\n",
 573                         Xml::fieldset( 'Foo', '' ),
 574                         'Entire element with legend but no content (empty string generates a closing tag)'
 575                 );
 576                 $this->assertEquals(
 577                         "<fieldset class=\"bar\">\n<legend>Foo</legend>\nBar\n</fieldset>\n",
 578                         Xml::fieldset( 'Foo', 'Bar', [ 'class' => 'bar' ] ),
 579                         'Opening tag with legend and attributes'
 580                 );
 581                 $this->assertEquals(
 582                         "<fieldset class=\"bar\">\n<legend>Foo</legend>\n",
 583                         Xml::fieldset( 'Foo', false, [ 'class' => 'bar' ] ),
 584                         'Entire element with legend and attributes'
 585                 );
 586         }
 587
 588         /**
 589          * @covers Xml::buildTable
 590          */
 591         public function testBuildTable() {
 592                 $firstRow = [ 'foo', 'bar' ];
 593                 $secondRow = [ 'Berlin', 'Tehran' ];
 594                 $headers = [ 'header1', 'header2' ];
 595                 $expected = '<table id="testTable"><thead id="testTable"><th>header1</th>' .
 596                         '<th>header2</th></thead><tr><td>foo</td><td>bar</td></tr><tr><td>Berlin</td>' .
 597                         '<td>Tehran</td></tr></table>';
 598                 $this->assertEquals(
 599                         $expected,
 600                         Xml::buildTable(
 601                                 [ $firstRow, $secondRow ],
 602                                 [ 'id' => 'testTable' ],
 603                                 $headers
 604                         )
 605                 );
 606         }
 607
 608         /**
 609          * @covers Xml::buildTableRow
 610          */
 611         public function testBuildTableRow() {
 612                 $this->assertEquals(
 613                         '<tr id="testRow"><td>foo</td><td>bar</td></tr>',
 614                         Xml::buildTableRow( [ 'id' => 'testRow' ], [ 'foo', 'bar' ] )
 615                 );
 616         }
 617 }