tests/qunit/suites/resources/mediawiki/mediawiki.jqueryMsg.test.js

   1 ( function ( mw, $ ) {
   2         var mwLanguageCache = {}, oldGetOuterHtml, formatnumTests, specialCharactersPageName,
   3                 expectedListUsers, expectedEntrypoints;
   4
   5         QUnit.module( 'mediawiki.jqueryMsg', QUnit.newMwEnvironment( {
   6                 setup: function () {
   7                         this.orgMwLangauge = mw.language;
   8                         mw.language = $.extend( true, {}, this.orgMwLangauge );
   9                         oldGetOuterHtml = $.fn.getOuterHtml;
  10                         $.fn.getOuterHtml = function () {
  11                                 var $div = $( '<div>' ), html;
  12                                 $div.append( $( this ).eq( 0 ).clone() );
  13                                 html = $div.html();
  14                                 $div.empty();
  15                                 $div = undefined;
  16                                 return html;
  17                         };
  18
  19                         // Messages that are reused in multiple tests
  20                         mw.messages.set( {
  21                                 // The values for gender are not significant,
  22                                 // what matters is which of the values is choosen by the parser
  23                                 'gender-msg': '$1: {{GENDER:$2|blue|pink|green}}',
  24
  25                                 'plural-msg': 'Found $1 {{PLURAL:$1|item|items}}',
  26
  27                                 // Assume the grammar form grammar_case_foo is not valid in any language
  28                                 'grammar-msg': 'Przeszukaj {{GRAMMAR:grammar_case_foo|{{SITENAME}}}}',
  29
  30                                 'formatnum-msg': '{{formatnum:$1}}',
  31
  32                                 'portal-url': 'Project:Community portal',
  33                                 'see-portal-url': '{{Int:portal-url}} is an important community page.',
  34
  35                                 'jquerymsg-test-statistics-users': '注册[[Special:ListUsers|用户]]',
  36
  37                                 'jquerymsg-test-version-entrypoints-index-php': '[https://www.mediawiki.org/wiki/Manual:index.php index.php]',
  38
  39                                 'external-link-replace': 'Foo [$1 bar]'
  40                         } );
  41
  42                         specialCharactersPageName = '"Who" wants to be a millionaire & live on \'Exotic Island\'?';
  43
  44                         expectedListUsers = '注册' + $( '<a>' ).attr( {
  45                                 title: 'Special:ListUsers',
  46                                 href: mw.util.wikiGetlink( 'Special:ListUsers' )
  47                         } ).text( '用户' ).getOuterHtml();
  48
  49                         expectedEntrypoints = '<a href="https://www.mediawiki.org/wiki/Manual:index.php">index.php</a>';
  50                 },
  51                 teardown: function () {
  52                         mw.language = this.orgMwLangauge;
  53                         $.fn.getOuterHtml = oldGetOuterHtml;
  54                 }
  55         } ) );
  56
  57         function getMwLanguage( langCode, cb ) {
  58                 if ( mwLanguageCache[langCode] !== undefined ) {
  59                         mwLanguageCache[langCode].add( cb );
  60                         return;
  61                 }
  62                 mwLanguageCache[langCode] = $.Callbacks( 'once memory' );
  63                 mwLanguageCache[langCode].add( cb );
  64                 $.ajax( {
  65                         url: mw.util.wikiScript( 'load' ),
  66                         data: {
  67                                 skin: mw.config.get( 'skin' ),
  68                                 lang: langCode,
  69                                 debug: mw.config.get( 'debug' ),
  70                                 modules: [
  71                                         'mediawiki.language.data',
  72                                         'mediawiki.language'
  73                                 ].join( '|' ),
  74                                 only: 'scripts'
  75                         },
  76                         dataType: 'script'
  77                 } ).done(function () {
  78                                 mwLanguageCache[langCode].fire( mw.language );
  79                         } ).fail( function () {
  80                                 mwLanguageCache[langCode].fire( false );
  81                         } );
  82         }
  83
  84         QUnit.test( 'Replace', 9, function ( assert ) {
  85                 var parser = mw.jqueryMsg.getMessageFunction();
  86
  87                 mw.messages.set( 'simple', 'Foo $1 baz $2' );
  88
  89                 assert.equal( parser( 'simple' ), 'Foo $1 baz $2', 'Replacements with no substitutes' );
  90                 assert.equal( parser( 'simple', 'bar' ), 'Foo bar baz $2', 'Replacements with less substitutes' );
  91                 assert.equal( parser( 'simple', 'bar', 'quux' ), 'Foo bar baz quux', 'Replacements with all substitutes' );
  92
  93                 mw.messages.set( 'plain-input', '<foo foo="foo">x$1y&lt;</foo>z' );
  94
  95                 assert.equal(
  96                         parser( 'plain-input', 'bar' ),
  97                         '&lt;foo foo="foo"&gt;xbary&amp;lt;&lt;/foo&gt;z',
  98                         'Input is not considered html'
  99                 );
 100
 101                 mw.messages.set( 'plain-replace', 'Foo $1' );
 102
 103                 assert.equal(
 104                         parser( 'plain-replace', '<bar bar="bar">&gt;</bar>' ),
 105                         'Foo &lt;bar bar="bar"&gt;&amp;gt;&lt;/bar&gt;',
 106                         'Replacement is not considered html'
 107                 );
 108
 109                 mw.messages.set( 'object-replace', 'Foo $1' );
 110
 111                 assert.equal(
 112                         parser( 'object-replace', $( '<div class="bar">&gt;</div>' ) ),
 113                         'Foo <div class="bar">&gt;</div>',
 114                         'jQuery objects are preserved as raw html'
 115                 );
 116
 117                 assert.equal(
 118                         parser( 'object-replace', $( '<div class="bar">&gt;</div>' ).get( 0 ) ),
 119                         'Foo <div class="bar">&gt;</div>',
 120                         'HTMLElement objects are preserved as raw html'
 121                 );
 122
 123                 assert.equal(
 124                         parser( 'object-replace', $( '<div class="bar">&gt;</div>' ).toArray() ),
 125                         'Foo <div class="bar">&gt;</div>',
 126                         'HTMLElement[] arrays are preserved as raw html'
 127                 );
 128
 129                 assert.equal(
 130                         parser( 'external-link-replace', 'http://example.org/?x=y&z' ),
 131                         'Foo <a href="http://example.org/?x=y&amp;z">bar</a>',
 132                         'Href is not double-escaped in wikilink function'
 133                 );
 134         } );
 135
 136         QUnit.test( 'Plural', 3, function ( assert ) {
 137                 var parser = mw.jqueryMsg.getMessageFunction();
 138
 139                 assert.equal( parser( 'plural-msg', 0 ), 'Found 0 items', 'Plural test for english with zero as count' );
 140                 assert.equal( parser( 'plural-msg', 1 ), 'Found 1 item', 'Singular test for english' );
 141                 assert.equal( parser( 'plural-msg', 2 ), 'Found 2 items', 'Plural test for english' );
 142         } );
 143
 144         QUnit.test( 'Gender', 11, function ( assert ) {
 145                 // TODO: These tests should be for mw.msg once mw.msg integrated with mw.jqueryMsg
 146                 // TODO: English may not be the best language for these tests. Use a language like Arabic or Russian
 147                 var user = mw.user,
 148                         parser = mw.jqueryMsg.getMessageFunction();
 149
 150                 user.options.set( 'gender', 'male' );
 151                 assert.equal(
 152                         parser( 'gender-msg', 'Bob', 'male' ),
 153                         'Bob: blue',
 154                         'Masculine from string "male"'
 155                 );
 156                 assert.equal(
 157                         parser( 'gender-msg', 'Bob', user ),
 158                         'Bob: blue',
 159                         'Masculine from mw.user object'
 160                 );
 161
 162                 user.options.set( 'gender', 'unknown' );
 163                 assert.equal(
 164                         parser( 'gender-msg', 'Foo', user ),
 165                         'Foo: green',
 166                         'Neutral from mw.user object' );
 167                 assert.equal(
 168                         parser( 'gender-msg', 'Alice', 'female' ),
 169                         'Alice: pink',
 170                         'Feminine from string "female"' );
 171                 assert.equal(
 172                         parser( 'gender-msg', 'User' ),
 173                         'User: green',
 174                         'Neutral when no parameter given' );
 175                 assert.equal(
 176                         parser( 'gender-msg', 'User', 'unknown' ),
 177                         'User: green',
 178                         'Neutral from string "unknown"'
 179                 );
 180
 181                 mw.messages.set( 'gender-msg-one-form', '{{GENDER:$1|User}}: $2 {{PLURAL:$2|edit|edits}}' );
 182
 183                 assert.equal(
 184                         parser( 'gender-msg-one-form', 'male', 10 ),
 185                         'User: 10 edits',
 186                         'Gender neutral and plural form'
 187                 );
 188                 assert.equal(
 189                         parser( 'gender-msg-one-form', 'female', 1 ),
 190                         'User: 1 edit',
 191                         'Gender neutral and singular form'
 192                 );
 193
 194                 mw.messages.set( 'gender-msg-lowercase', '{{gender:$1|he|she}} is awesome' );
 195                 assert.equal(
 196                         parser( 'gender-msg-lowercase', 'male' ),
 197                         'he is awesome',
 198                         'Gender masculine'
 199                 );
 200                 assert.equal(
 201                         parser( 'gender-msg-lowercase', 'female' ),
 202                         'she is awesome',
 203                         'Gender feminine'
 204                 );
 205
 206                 mw.messages.set( 'gender-msg-wrong', '{{gender}} test' );
 207                 assert.equal(
 208                         parser( 'gender-msg-wrong', 'female' ),
 209                         ' test',
 210                         'Invalid syntax should result in {{gender}} simply being stripped away'
 211                 );
 212         } );
 213
 214         QUnit.test( 'Grammar', 2, function ( assert ) {
 215                 var parser = mw.jqueryMsg.getMessageFunction();
 216
 217                 assert.equal( parser( 'grammar-msg' ), 'Przeszukaj ' + mw.config.get( 'wgSiteName' ), 'Grammar Test with sitename' );
 218
 219                 mw.messages.set( 'grammar-msg-wrong-syntax', 'Przeszukaj {{GRAMMAR:grammar_case_xyz}}' );
 220                 assert.equal( parser( 'grammar-msg-wrong-syntax' ), 'Przeszukaj ', 'Grammar Test with wrong grammar template syntax' );
 221         } );
 222
 223         QUnit.test( 'Match PHP parser', mw.libs.phpParserData.tests.length, function ( assert ) {
 224                 mw.messages.set( mw.libs.phpParserData.messages );
 225                 $.each( mw.libs.phpParserData.tests, function ( i, test ) {
 226                         QUnit.stop();
 227                         getMwLanguage( test.lang, function ( langClass ) {
 228                                 QUnit.start();
 229                                 if ( !langClass ) {
 230                                         assert.ok( false, 'Language "' + test.lang + '" failed to load' );
 231                                         return;
 232                                 }
 233                                 mw.config.set( 'wgUserLanguage', test.lang );
 234                                 var parser = new mw.jqueryMsg.parser( { language: langClass } );
 235                                 assert.equal(
 236                                         parser.parse( test.key, test.args ).html(),
 237                                         test.result,
 238                                         test.name
 239                                 );
 240                         } );
 241                 } );
 242         } );
 243
 244         QUnit.test( 'Links', 6, function ( assert ) {
 245                 var parser = mw.jqueryMsg.getMessageFunction(),
 246                         expectedDisambiguationsText,
 247                         expectedMultipleBars,
 248                         expectedSpecialCharacters;
 249
 250                 /*
 251                  The below three are all identical to or based on real messages.  For disambiguations-text,
 252                  the bold was removed because it is not yet implemented.
 253                  */
 254
 255                 assert.equal(
 256                         parser( 'jquerymsg-test-statistics-users' ),
 257                         expectedListUsers,
 258                         'Piped wikilink'
 259                 );
 260
 261                 expectedDisambiguationsText = 'The following pages contain at least one link to a disambiguation page.\nThey may have to link to a more appropriate page instead.\nA page is treated as a disambiguation page if it uses a template that is linked from ' +
 262                         $( '<a>' ).attr( {
 263                                 title: 'MediaWiki:Disambiguationspage',
 264                                 href: mw.util.wikiGetlink( 'MediaWiki:Disambiguationspage' )
 265                         } ).text( 'MediaWiki:Disambiguationspage' ).getOuterHtml() + '.';
 266                 mw.messages.set( 'disambiguations-text', 'The following pages contain at least one link to a disambiguation page.\nThey may have to link to a more appropriate page instead.\nA page is treated as a disambiguation page if it uses a template that is linked from [[MediaWiki:Disambiguationspage]].' );
 267                 assert.equal(
 268                         parser( 'disambiguations-text' ),
 269                         expectedDisambiguationsText,
 270                         'Wikilink without pipe'
 271                 );
 272
 273                 assert.equal(
 274                         parser( 'jquerymsg-test-version-entrypoints-index-php' ),
 275                         expectedEntrypoints,
 276                         'External link'
 277                 );
 278
 279                 // Pipe trick is not supported currently, but should not parse as text either.
 280                 mw.messages.set( 'pipe-trick', '[[Tampa, Florida|]]' );
 281                 assert.equal(
 282                         parser( 'pipe-trick' ),
 283                         'pipe-trick: Parse error at position 0 in input: [[Tampa, Florida|]]',
 284                         'Pipe trick should return error string.'
 285                 );
 286
 287                 expectedMultipleBars = $( '<a>' ).attr( {
 288                         title: 'Main Page',
 289                         href: mw.util.wikiGetlink( 'Main Page' )
 290                 } ).text( 'Main|Page' ).getOuterHtml();
 291                 mw.messages.set( 'multiple-bars', '[[Main Page|Main|Page]]' );
 292                 assert.equal(
 293                         parser( 'multiple-bars' ),
 294                         expectedMultipleBars,
 295                         'Bar in anchor'
 296                 );
 297
 298                 expectedSpecialCharacters = $( '<a>' ).attr( {
 299                         title: specialCharactersPageName,
 300                         href: mw.util.wikiGetlink( specialCharactersPageName )
 301                 } ).text( specialCharactersPageName ).getOuterHtml();
 302
 303                 mw.messages.set( 'special-characters', '[[' + specialCharactersPageName + ']]' );
 304                 assert.equal(
 305                         parser( 'special-characters' ),
 306                         expectedSpecialCharacters,
 307                         'Special characters'
 308                 );
 309         } );
 310
 311 // Tests that {{-transformation vs. general parsing are done as requested
 312         QUnit.test( 'Curly brace transformation', 14, function ( assert ) {
 313                 var formatText, formatParse, oldUserLang;
 314
 315                 oldUserLang = mw.config.get( 'wgUserLanguage' );
 316
 317                 formatText = mw.jqueryMsg.getMessageFunction( {
 318                         format: 'text'
 319                 } );
 320
 321                 formatParse = mw.jqueryMsg.getMessageFunction( {
 322                         format: 'parse'
 323                 } );
 324
 325                 // When the expected result is the same in both modes
 326                 function assertBothModes( parserArguments, expectedResult, assertMessage ) {
 327                         assert.equal( formatText.apply( null, parserArguments ), expectedResult, assertMessage + ' when format is \'text\'' );
 328                         assert.equal( formatParse.apply( null, parserArguments ), expectedResult, assertMessage + ' when format is \'parse\'' );
 329                 }
 330
 331                 assertBothModes( ['gender-msg', 'Bob', 'male'], 'Bob: blue', 'gender is resolved' );
 332
 333                 assertBothModes( ['plural-msg', 5], 'Found 5 items', 'plural is resolved' );
 334
 335                 assertBothModes( ['grammar-msg'], 'Przeszukaj ' + mw.config.get( 'wgSiteName' ), 'grammar is resolved' );
 336
 337                 mw.config.set( 'wgUserLanguage', 'en' );
 338                 assertBothModes( ['formatnum-msg', '987654321.654321'], '987654321.654321', 'formatnum is resolved' );
 339
 340                 // Test non-{{ wikitext, where behavior differs
 341
 342                 // Wikilink
 343                 assert.equal(
 344                         formatText( 'jquerymsg-test-statistics-users' ),
 345                         mw.messages.get( 'jquerymsg-test-statistics-users' ),
 346                         'Internal link message unchanged when format is \'text\''
 347                 );
 348                 assert.equal(
 349                         formatParse( 'jquerymsg-test-statistics-users' ),
 350                         expectedListUsers,
 351                         'Internal link message parsed when format is \'parse\''
 352                 );
 353
 354                 // External link
 355                 assert.equal(
 356                         formatText( 'jquerymsg-test-version-entrypoints-index-php' ),
 357                         mw.messages.get( 'jquerymsg-test-version-entrypoints-index-php' ),
 358                         'External link message unchanged when format is \'text\''
 359                 );
 360                 assert.equal(
 361                         formatParse( 'jquerymsg-test-version-entrypoints-index-php' ),
 362                         expectedEntrypoints,
 363                         'External link message processed when format is \'parse\''
 364                 );
 365
 366                 // External link with parameter
 367                 assert.equal(
 368                         formatText( 'external-link-replace', 'http://example.com' ),
 369                         'Foo [http://example.com bar]',
 370                         'External link message only substitutes parameter when format is \'text\''
 371                 );
 372                 assert.equal(
 373                         formatParse( 'external-link-replace', 'http://example.com' ),
 374                         'Foo <a href="http://example.com">bar</a>',
 375                         'External link message processed when format is \'parse\''
 376                 );
 377
 378                 mw.config.set( 'wgUserLanguage', oldUserLang );
 379         } );
 380
 381         QUnit.test( 'Int', 4, function ( assert ) {
 382                 var parser = mw.jqueryMsg.getMessageFunction(),
 383                         newarticletextSource = 'You have followed a link to a page that does not exist yet. To create the page, start typing in the box below (see the [[{{Int:Helppage}}|help page]] for more info). If you are here by mistake, click your browser\'s back button.',
 384                         expectedNewarticletext;
 385
 386                 mw.messages.set( 'helppage', 'Help:Contents' );
 387
 388                 expectedNewarticletext = 'You have followed a link to a page that does not exist yet. To create the page, start typing in the box below (see the ' +
 389                         $( '<a>' ).attr( {
 390                                 title: mw.msg( 'helppage' ),
 391                                 href: mw.util.wikiGetlink( mw.msg( 'helppage' ) )
 392                         } ).text( 'help page' ).getOuterHtml() + ' for more info). If you are here by mistake, click your browser\'s back button.';
 393
 394                 mw.messages.set( 'newarticletext', newarticletextSource );
 395
 396                 assert.equal(
 397                         parser( 'newarticletext' ),
 398                         expectedNewarticletext,
 399                         'Link with nested message'
 400                 );
 401
 402                 assert.equal(
 403                         parser( 'see-portal-url' ),
 404                         'Project:Community portal is an important community page.',
 405                         'Nested message'
 406                 );
 407
 408                 mw.messages.set( 'newarticletext-lowercase',
 409                         newarticletextSource.replace( 'Int:Helppage', 'int:helppage' ) );
 410
 411                 assert.equal(
 412                         parser( 'newarticletext-lowercase' ),
 413                         expectedNewarticletext,
 414                         'Link with nested message, lowercase include'
 415                 );
 416
 417                 mw.messages.set( 'uses-missing-int', '{{int:doesnt-exist}}' );
 418
 419                 assert.equal(
 420                         parser( 'uses-missing-int' ),
 421                         '[doesnt-exist]',
 422                         'int: where nested message does not exist'
 423                 );
 424         } );
 425
 426 // Tests that getMessageFunction is used for non-plain messages with curly braces or
 427 // square brackets, but not otherwise.
 428         QUnit.test( 'mw.Message.prototype.parser monkey-patch', 22, function ( assert ) {
 429                 var oldGMF, outerCalled, innerCalled;
 430
 431                 mw.messages.set( {
 432                         'curly-brace': '{{int:message}}',
 433                         'single-square-bracket': '[https://www.mediawiki.org/ MediaWiki]',
 434                         'double-square-bracket': '[[Some page]]',
 435                         'regular': 'Other message'
 436                 } );
 437
 438                 oldGMF = mw.jqueryMsg.getMessageFunction;
 439
 440                 mw.jqueryMsg.getMessageFunction = function () {
 441                         outerCalled = true;
 442                         return function () {
 443                                 innerCalled = true;
 444                         };
 445                 };
 446
 447                 function verifyGetMessageFunction( key, format, shouldCall ) {
 448                         var message;
 449                         outerCalled = false;
 450                         innerCalled = false;
 451                         message = mw.message( key );
 452                         message[format]();
 453                         assert.strictEqual( outerCalled, shouldCall, 'Outer function called for ' + key );
 454                         assert.strictEqual( innerCalled, shouldCall, 'Inner function called for ' + key );
 455                 }
 456
 457                 verifyGetMessageFunction( 'curly-brace', 'parse', true );
 458                 verifyGetMessageFunction( 'curly-brace', 'plain', false );
 459
 460                 verifyGetMessageFunction( 'single-square-bracket', 'parse', true );
 461                 verifyGetMessageFunction( 'single-square-bracket', 'plain', false );
 462
 463                 verifyGetMessageFunction( 'double-square-bracket', 'parse', true );
 464                 verifyGetMessageFunction( 'double-square-bracket', 'plain', false );
 465
 466                 verifyGetMessageFunction( 'regular', 'parse', false );
 467                 verifyGetMessageFunction( 'regular', 'plain', false );
 468
 469                 verifyGetMessageFunction( 'jquerymsg-test-pagetriage-del-talk-page-notify-summary', 'plain', false );
 470                 verifyGetMessageFunction( 'jquerymsg-test-categorytree-collapse-bullet', 'plain', false );
 471                 verifyGetMessageFunction( 'jquerymsg-test-wikieditor-toolbar-help-content-signature-result', 'plain', false );
 472
 473                 mw.jqueryMsg.getMessageFunction = oldGMF;
 474         } );
 475
 476         formatnumTests = [
 477                 {
 478                         lang: 'en',
 479                         number: 987654321.654321,
 480                         result: '987654321.654321',
 481                         description: 'formatnum test for English, decimal seperator'
 482                 },
 483                 {
 484                         lang: 'ar',
 485                         number: 987654321.654321,
 486                         result: '٩٨٧٦٥٤٣٢١٫٦٥٤٣٢١',
 487                         description: 'formatnum test for Arabic, with decimal seperator'
 488                 },
 489                 {
 490                         lang: 'ar',
 491                         number: '٩٨٧٦٥٤٣٢١٫٦٥٤٣٢١',
 492                         result: 987654321,
 493                         integer: true,
 494                         description: 'formatnum test for Arabic, with decimal seperator, reverse'
 495                 },
 496                 {
 497                         lang: 'ar',
 498                         number: -12.89,
 499                         result: '-١٢٫٨٩',
 500                         description: 'formatnum test for Arabic, negative number'
 501                 },
 502                 {
 503                         lang: 'ar',
 504                         number: '-١٢٫٨٩',
 505                         result: -12,
 506                         integer: true,
 507                         description: 'formatnum test for Arabic, negative number, reverse'
 508                 },
 509                 {
 510                         lang: 'nl',
 511                         number: 987654321.654321,
 512                         result: '987654321,654321',
 513                         description: 'formatnum test for Nederlands, decimal seperator'
 514                 },
 515                 {
 516                         lang: 'nl',
 517                         number: -12.89,
 518                         result: '-12,89',
 519                         description: 'formatnum test for Nederlands, negative number'
 520                 },
 521                 {
 522                         lang: 'nl',
 523                         number: 'invalidnumber',
 524                         result: 'invalidnumber',
 525                         description: 'formatnum test for Nederlands, invalid number'
 526                 }
 527         ];
 528
 529         QUnit.test( 'formatnum', formatnumTests.length, function ( assert ) {
 530                 mw.messages.set( 'formatnum-msg-int', '{{formatnum:$1|R}}' );
 531                 $.each( formatnumTests, function ( i, test ) {
 532                         QUnit.stop();
 533                         getMwLanguage( test.lang, function ( langClass ) {
 534                                 QUnit.start();
 535                                 if ( !langClass ) {
 536                                         assert.ok( false, 'Language "' + test.lang + '" failed to load' );
 537                                         return;
 538                                 }
 539                                 mw.messages.set( test.message );
 540                                 mw.config.set( 'wgUserLanguage', test.lang );
 541                                 var parser = new mw.jqueryMsg.parser( { language: langClass } );
 542                                 assert.equal(
 543                                         parser.parse( test.integer ? 'formatnum-msg-int' : 'formatnum-msg',
 544                                                 [ test.number ] ).html(),
 545                                         test.result,
 546                                         test.description
 547                                 );
 548                         } );
 549                 } );
 550         } );
 551
 552 }( mediaWiki, jQuery ) );