tests/phpunit/includes/api/ApiQuerySiteinfoTest.php

   1 <?php
   2
   3 use MediaWiki\MediaWikiServices;
   4
   5 /**
   6  * @group API
   7  * @group medium
   8  * @group Database
   9  *
  10  * @covers ApiQuerySiteinfo
  11  */
  12 class ApiQuerySiteinfoTest extends ApiTestCase {
  13         // We don't try to test every single thing for every category, just a sample
  14
  15         protected function doQuery( $siprop = null, $extraParams = [] ) {
  16                 $params = [ 'action' => 'query', 'meta' => 'siteinfo' ];
  17                 if ( $siprop !== null ) {
  18                         $params['siprop'] = $siprop;
  19                 }
  20                 $params = array_merge( $params, $extraParams );
  21
  22                 $res = $this->doApiRequest( $params );
  23
  24                 $this->assertArrayNotHasKey( 'warnings', $res[0] );
  25                 $this->assertCount( 1, $res[0]['query'] );
  26
  27                 return $res[0]['query'][$siprop === null ? 'general' : $siprop];
  28         }
  29
  30         public function testGeneral() {
  31                 $this->setMwGlobals( [
  32                         'wgAllowExternalImagesFrom' => '//localhost/',
  33                 ] );
  34
  35                 $data = $this->doQuery();
  36
  37                 $this->assertSame( Title::newMainPage()->getPrefixedText(), $data['mainpage'] );
  38                 $this->assertSame( PHP_VERSION, $data['phpversion'] );
  39                 $this->assertSame( [ '//localhost/' ], $data['externalimages'] );
  40         }
  41
  42         public function testLinkPrefixCharset() {
  43                 global $wgContLang;
  44
  45                 $this->setContentLang( 'ar' );
  46                 $this->assertTrue( $wgContLang->linkPrefixExtension(), 'Sanity check' );
  47
  48                 $data = $this->doQuery();
  49
  50                 $this->assertSame( $wgContLang->linkPrefixCharset(), $data['linkprefixcharset'] );
  51         }
  52
  53         public function testVariants() {
  54                 global $wgContLang;
  55
  56                 $this->setContentLang( 'zh' );
  57                 $this->assertTrue( $wgContLang->hasVariants(), 'Sanity check' );
  58
  59                 $data = $this->doQuery();
  60
  61                 $expected = array_map(
  62                         function ( $code ) use ( $wgContLang ) {
  63                                 return [ 'code' => $code, 'name' => $wgContLang->getVariantname( $code ) ];
  64                         },
  65                         $wgContLang->getVariants()
  66                 );
  67
  68                 $this->assertSame( $expected, $data['variants'] );
  69         }
  70
  71         public function testReadOnly() {
  72                 $svc = \MediaWiki\MediaWikiServices::getInstance()->getReadOnlyMode();
  73                 $svc->setReason( 'Need more donations' );
  74                 try {
  75                         $data = $this->doQuery();
  76                 } finally {
  77                         $svc->setReason( false );
  78                 }
  79
  80                 $this->assertTrue( $data['readonly'] );
  81                 $this->assertSame( 'Need more donations', $data['readonlyreason'] );
  82         }
  83
  84         public function testNamespaces() {
  85                 global $wgContLang;
  86
  87                 $this->setMwGlobals( 'wgExtraNamespaces', [ '138' => 'Testing' ] );
  88
  89                 $this->assertSame( array_keys( $wgContLang->getFormattedNamespaces() ),
  90                         array_keys( $this->doQuery( 'namespaces' ) ) );
  91         }
  92
  93         public function testNamespaceAliases() {
  94                 global $wgNamespaceAliases, $wgContLang;
  95
  96                 $expected = array_merge( $wgNamespaceAliases, $wgContLang->getNamespaceAliases() );
  97                 $expected = array_map(
  98                         function ( $key, $val ) {
  99                                 return [ 'id' => $val, 'alias' => strtr( $key, '_', ' ' ) ];
 100                         },
 101                         array_keys( $expected ),
 102                         $expected
 103                 );
 104
 105                 // Test that we don't list duplicates
 106                 $this->mergeMwGlobalArrayValue( 'wgNamespaceAliases', [ 'Talk' => NS_TALK ] );
 107
 108                 $this->assertSame( $expected, $this->doQuery( 'namespacealiases' ) );
 109         }
 110
 111         public function testSpecialPageAliases() {
 112                 $this->assertCount(
 113                         count( MediaWikiServices::getInstance()->getSpecialPageFactory()->getNames() ),
 114                         $this->doQuery( 'specialpagealiases' )
 115                 );
 116         }
 117
 118         public function testMagicWords() {
 119                 global $wgContLang;
 120
 121                 $this->assertCount(
 122                         count( $wgContLang->getMagicWords() ),
 123                         $this->doQuery( 'magicwords' )
 124                 );
 125         }
 126
 127         /**
 128          * @dataProvider interwikiMapProvider
 129          */
 130         public function testInterwikiMap( $filter ) {
 131                 global $wgServer, $wgScriptPath;
 132
 133                 $dbw = wfGetDB( DB_MASTER );
 134                 $dbw->insert(
 135                         'interwiki',
 136                         [
 137                                 [
 138                                         'iw_prefix' => 'self',
 139                                         'iw_url' => "$wgServer$wgScriptPath/index.php?title=$1",
 140                                         'iw_api' => "$wgServer$wgScriptPath/api.php",
 141                                         'iw_wikiid' => 'somedbname',
 142                                         'iw_local' => true,
 143                                         'iw_trans' => true,
 144                                 ],
 145                                 [
 146                                         'iw_prefix' => 'foreign',
 147                                         'iw_url' => '//foreign.example/wiki/$1',
 148                                         'iw_api' => '',
 149                                         'iw_wikiid' => '',
 150                                         'iw_local' => false,
 151                                         'iw_trans' => false,
 152                                 ],
 153                         ],
 154                         __METHOD__,
 155                         'IGNORE'
 156                 );
 157                 $this->tablesUsed[] = 'interwiki';
 158
 159                 $this->setMwGlobals( [
 160                         'wgLocalInterwikis' => [ 'self' ],
 161                         'wgExtraInterlanguageLinkPrefixes' => [ 'self' ],
 162                         'wgExtraLanguageNames' => [ 'self' => 'Recursion' ],
 163                 ] );
 164
 165                 MessageCache::singleton()->enable();
 166
 167                 $this->editPage( 'MediaWiki:Interlanguage-link-self', 'Self!' );
 168                 $this->editPage( 'MediaWiki:Interlanguage-link-sitename-self', 'Circular logic' );
 169
 170                 $expected = [];
 171
 172                 if ( $filter === null || $filter === '!local' ) {
 173                         $expected[] = [
 174                                 'prefix' => 'foreign',
 175                                 'url' => wfExpandUrl( '//foreign.example/wiki/$1', PROTO_CURRENT ),
 176                                 'protorel' => true,
 177                         ];
 178                 }
 179                 if ( $filter === null || $filter === 'local' ) {
 180                         $expected[] = [
 181                                 'prefix' => 'self',
 182                                 'local' => true,
 183                                 'trans' => true,
 184                                 'language' => 'Recursion',
 185                                 'localinterwiki' => true,
 186                                 'extralanglink' => true,
 187                                 'linktext' => 'Self!',
 188                                 'sitename' => 'Circular logic',
 189                                 'url' => "$wgServer$wgScriptPath/index.php?title=$1",
 190                                 'protorel' => false,
 191                                 'wikiid' => 'somedbname',
 192                                 'api' => "$wgServer$wgScriptPath/api.php",
 193                         ];
 194                 }
 195
 196                 $data = $this->doQuery( 'interwikimap',
 197                         $filter === null ? [] : [ 'sifilteriw' => $filter ] );
 198
 199                 $this->assertSame( $expected, $data );
 200         }
 201
 202         public function interwikiMapProvider() {
 203                 return [ [ 'local' ], [ '!local' ], [ null ] ];
 204         }
 205
 206         /**
 207          * @dataProvider dbReplLagProvider
 208          */
 209         public function testDbReplLagInfo( $showHostnames, $includeAll ) {
 210                 if ( !$showHostnames && $includeAll ) {
 211                         $this->setExpectedApiException( 'apierror-siteinfo-includealldenied' );
 212                 }
 213
 214                 $mockLB = $this->getMockBuilder( LoadBalancer::class )
 215                         ->disableOriginalConstructor()
 216                         ->setMethods( [ 'getMaxLag', 'getLagTimes', 'getServerName', '__destruct' ] )
 217                         ->getMock();
 218                 $mockLB->method( 'getMaxLag' )->willReturn( [ null, 7, 1 ] );
 219                 $mockLB->method( 'getLagTimes' )->willReturn( [ 5, 7 ] );
 220                 $mockLB->method( 'getServerName' )->will( $this->returnValueMap( [
 221                         [ 0, 'apple' ], [ 1, 'carrot' ]
 222                 ] ) );
 223                 $this->setService( 'DBLoadBalancer', $mockLB );
 224
 225                 $this->setMwGlobals( 'wgShowHostnames', $showHostnames );
 226
 227                 $expected = [];
 228                 if ( $includeAll ) {
 229                         $expected[] = [ 'host' => $showHostnames ? 'apple' : '', 'lag' => 5 ];
 230                 }
 231                 $expected[] = [ 'host' => $showHostnames ? 'carrot' : '', 'lag' => 7 ];
 232
 233                 $data = $this->doQuery( 'dbrepllag', $includeAll ? [ 'sishowalldb' => '' ] : [] );
 234
 235                 $this->assertSame( $expected, $data );
 236         }
 237
 238         public function dbReplLagProvider() {
 239                 return [
 240                         'no hostnames, no showalldb' => [ false, false ],
 241                         'no hostnames, showalldb' => [ false, true ],
 242                         'hostnames, no showalldb' => [ true, false ],
 243                         'hostnames, showalldb' => [ true, true ]
 244                 ];
 245         }
 246
 247         public function testStatistics() {
 248                 $this->setTemporaryHook( 'APIQuerySiteInfoStatisticsInfo',
 249                         function ( &$data ) {
 250                                 $data['addedstats'] = 42;
 251                         }
 252                 );
 253
 254                 $expected = [
 255                         'pages' => intval( SiteStats::pages() ),
 256                         'articles' => intval( SiteStats::articles() ),
 257                         'edits' => intval( SiteStats::edits() ),
 258                         'images' => intval( SiteStats::images() ),
 259                         'users' => intval( SiteStats::users() ),
 260                         'activeusers' => intval( SiteStats::activeUsers() ),
 261                         'admins' => intval( SiteStats::numberingroup( 'sysop' ) ),
 262                         'jobs' => intval( SiteStats::jobs() ),
 263                         'addedstats' => 42,
 264                 ];
 265
 266                 $this->assertSame( $expected, $this->doQuery( 'statistics' ) );
 267         }
 268
 269         /**
 270          * @dataProvider groupsProvider
 271          */
 272         public function testUserGroups( $numInGroup ) {
 273                 global $wgGroupPermissions, $wgAutopromote;
 274
 275                 $this->setGroupPermissions( 'viscount', 'perambulate', 'yes' );
 276                 $this->setGroupPermissions( 'viscount', 'legislate', '0' );
 277                 $this->setMwGlobals( [
 278                         'wgAddGroups' => [ 'viscount' => true, 'bot' => [] ],
 279                         'wgRemoveGroups' => [ 'viscount' => [ 'sysop' ], 'bot' => [ '*', 'earl' ] ],
 280                         'wgGroupsAddToSelf' => [ 'bot' => [ 'bureaucrat', 'sysop' ] ],
 281                         'wgGroupsRemoveFromSelf' => [ 'bot' => [ 'bot' ] ],
 282                 ] );
 283
 284                 $data = $this->doQuery( 'usergroups', $numInGroup ? [ 'sinumberingroup' => '' ] : [] );
 285
 286                 $names = array_map(
 287                         function ( $val ) {
 288                                 return $val['name'];
 289                         },
 290                         $data
 291                 );
 292
 293                 $this->assertSame( array_keys( $wgGroupPermissions ), $names );
 294
 295                 foreach ( $data as $val ) {
 296                         if ( !$numInGroup ) {
 297                                 $expectedSize = null;
 298                         } elseif ( $val['name'] === 'user' ) {
 299                                 $expectedSize = SiteStats::users();
 300                         } elseif ( $val['name'] === '*' || isset( $wgAutopromote[$val['name']] ) ) {
 301                                 $expectedSize = null;
 302                         } else {
 303                                 $expectedSize = SiteStats::numberingroup( $val['name'] );
 304                         }
 305
 306                         if ( $expectedSize === null ) {
 307                                 $this->assertArrayNotHasKey( 'number', $val );
 308                         } else {
 309                                 $this->assertSame( $expectedSize, $val['number'] );
 310                         }
 311
 312                         if ( $val['name'] === 'viscount' ) {
 313                                 $viscountFound = true;
 314                                 $this->assertSame( [ 'perambulate' ], $val['rights'] );
 315                                 $this->assertSame( User::getAllGroups(), $val['add'] );
 316                         } elseif ( $val['name'] === 'bot' ) {
 317                                 $this->assertArrayNotHasKey( 'add', $val );
 318                                 $this->assertArrayNotHasKey( 'remove', $val );
 319                                 $this->assertSame( [ 'bureaucrat', 'sysop' ], $val['add-self'] );
 320                                 $this->assertSame( [ 'bot' ], $val['remove-self'] );
 321                         }
 322                 }
 323         }
 324
 325         public function testFileExtensions() {
 326                 global $wgFileExtensions;
 327
 328                 // Add duplicate
 329                 $this->setMwGlobals( 'wgFileExtensions', array_merge( $wgFileExtensions, [ 'png' ] ) );
 330
 331                 $expected = array_map(
 332                         function ( $val ) {
 333                                 return [ 'ext' => $val ];
 334                         },
 335                         array_unique( $wgFileExtensions )
 336                 );
 337
 338                 $this->assertSame( $expected, $this->doQuery( 'fileextensions' ) );
 339         }
 340
 341         public function groupsProvider() {
 342                 return [
 343                         'numingroup' => [ true ],
 344                         'nonumingroup' => [ false ],
 345                 ];
 346         }
 347
 348         public function testInstalledLibraries() {
 349                 // @todo Test no installed.json?  Moving installed.json to a different name temporarily
 350                 // seems a bit scary, but I don't see any other way to do it.
 351                 //
 352                 // @todo Install extensions/skins somehow so that we can test they're filtered out
 353                 global $IP;
 354
 355                 $path = "$IP/vendor/composer/installed.json";
 356                 if ( !file_exists( $path ) ) {
 357                         $this->markTestSkipped( 'No installed libraries' );
 358                 }
 359
 360                 $expected = ( new ComposerInstalled( $path ) )->getInstalledDependencies();
 361
 362                 $expected = array_filter( $expected,
 363                         function ( $info ) {
 364                                 return strpos( $info['type'], 'mediawiki-' ) !== 0;
 365                         }
 366                 );
 367
 368                 $expected = array_map(
 369                         function ( $name, $info ) {
 370                                 return [ 'name' => $name, 'version' => $info['version'] ];
 371                         },
 372                         array_keys( $expected ),
 373                         array_values( $expected )
 374                 );
 375
 376                 $this->assertSame( $expected, $this->doQuery( 'libraries' ) );
 377         }
 378
 379         public function testExtensions() {
 380                 $tmpdir = $this->getNewTempDirectory();
 381                 touch( "$tmpdir/ErsatzExtension.php" );
 382                 touch( "$tmpdir/LICENSE" );
 383                 touch( "$tmpdir/AUTHORS.txt" );
 384
 385                 $val = [
 386                         'path' => "$tmpdir/ErsatzExtension.php",
 387                         'name' => 'Ersatz Extension',
 388                         'namemsg' => 'ersatz-extension-name',
 389                         'author' => 'John Smith',
 390                         'version' => '0.0.2',
 391                         'url' => 'https://www.example.com/software/ersatz-extension',
 392                         'description' => 'An extension that is not what it seems.',
 393                         'descriptionmsg' => 'ersatz-extension-desc',
 394                         'license-name' => 'PD',
 395                 ];
 396
 397                 $this->setMwGlobals( 'wgExtensionCredits', [ 'api' => [
 398                         $val,
 399                         [
 400                                 'author' => [ 'John Smith', 'John Smith Jr.', '...' ],
 401                                 'descriptionmsg' => [ 'another-extension-desc', 'param' ] ],
 402                 ] ] );
 403
 404                 $data = $this->doQuery( 'extensions' );
 405
 406                 $this->assertCount( 2, $data );
 407
 408                 $this->assertSame( 'api', $data[0]['type'] );
 409
 410                 $sharedKeys = [ 'name', 'namemsg', 'description', 'descriptionmsg', 'author', 'url',
 411                         'version', 'license-name' ];
 412                 foreach ( $sharedKeys as $key ) {
 413                         $this->assertSame( $val[$key], $data[0][$key] );
 414                 }
 415
 416                 // @todo Test git info
 417
 418                 $this->assertSame(
 419                         Title::newFromText( 'Special:Version/License/Ersatz Extension' )->getLinkURL(),
 420                         $data[0]['license']
 421                 );
 422
 423                 $this->assertSame(
 424                         Title::newFromText( 'Special:Version/Credits/Ersatz Extension' )->getLinkURL(),
 425                         $data[0]['credits']
 426                 );
 427
 428                 $this->assertSame( 'another-extension-desc', $data[1]['descriptionmsg'] );
 429                 $this->assertSame( [ 'param' ], $data[1]['descriptionmsgparams'] );
 430                 $this->assertSame( 'John Smith, John Smith Jr., ...', $data[1]['author'] );
 431         }
 432
 433         /**
 434          * @dataProvider rightsInfoProvider
 435          */
 436         public function testRightsInfo( $page, $url, $text, $expectedUrl, $expectedText ) {
 437                 $this->setMwGlobals( [
 438                         'wgRightsPage' => $page,
 439                         'wgRightsUrl' => $url,
 440                         'wgRightsText' => $text,
 441                 ] );
 442
 443                 $this->assertSame(
 444                         [ 'url' => $expectedUrl, 'text' => $expectedText ],
 445                         $this->doQuery( 'rightsinfo' )
 446                 );
 447         }
 448
 449         public function rightsInfoProvider() {
 450                 $textUrl = wfExpandUrl( Title::newFromText( 'License' ), PROTO_CURRENT );
 451                 $url = 'http://license.example/';
 452
 453                 return [
 454                         'No rights info' => [ null, null, null, '', '' ],
 455                         'Only page' => [ 'License', null, null, $textUrl, 'License' ],
 456                         'Only URL' => [ null, $url, null, $url, '' ],
 457                         'Only text' => [ null, null, '!!!', '', '!!!' ],
 458                         // URL is ignored if page is specified
 459                         'Page and URL' => [ 'License', $url, null, $textUrl, 'License' ],
 460                         'URL and text' => [ null, $url, '!!!', $url, '!!!' ],
 461                         'Page and text' => [ 'License', null, '!!!', $textUrl, '!!!' ],
 462                         'Page and URL and text' => [ 'License', $url, '!!!', $textUrl, '!!!' ],
 463                         'Pagename "0"' => [ '0', null, null,
 464                                 wfExpandUrl( Title::newFromText( '0' ), PROTO_CURRENT ), '0' ],
 465                         'URL "0"' => [ null, '0', null, '0', '' ],
 466                         'Text "0"' => [ null, null, '0', '', '0' ],
 467                 ];
 468         }
 469
 470         public function testRestrictions() {
 471                 global $wgRestrictionTypes, $wgRestrictionLevels, $wgCascadingRestrictionLevels,
 472                         $wgSemiprotectedRestrictionLevels;
 473
 474                 $this->assertSame( [
 475                         'types' => $wgRestrictionTypes,
 476                         'levels' => $wgRestrictionLevels,
 477                         'cascadinglevels' => $wgCascadingRestrictionLevels,
 478                         'semiprotectedlevels' => $wgSemiprotectedRestrictionLevels,
 479                 ], $this->doQuery( 'restrictions' ) );
 480         }
 481
 482         /**
 483          * @dataProvider languagesProvider
 484          */
 485         public function testLanguages( $langCode ) {
 486                 $expected = Language::fetchLanguageNames( (string)$langCode );
 487
 488                 $expected = array_map(
 489                         function ( $code, $name ) {
 490                                 return [
 491                                         'code' => $code,
 492                                         'name' => $name
 493                                 ];
 494                         },
 495                         array_keys( $expected ),
 496                         array_values( $expected )
 497                 );
 498
 499                 $data = $this->doQuery( 'languages',
 500                         $langCode !== null ? [ 'siinlanguagecode' => $langCode ] : [] );
 501
 502                 $this->assertSame( $expected, $data );
 503         }
 504
 505         public function languagesProvider() {
 506                 return [ [ null ], [ 'fr' ] ];
 507         }
 508
 509         public function testLanguageVariants() {
 510                 $expectedKeys = array_filter( LanguageConverter::$languagesWithVariants,
 511                         function ( $langCode ) {
 512                                 return !Language::factory( $langCode )->getConverter() instanceof FakeConverter;
 513                         }
 514                 );
 515                 sort( $expectedKeys );
 516
 517                 $this->assertSame( $expectedKeys, array_keys( $this->doQuery( 'languagevariants' ) ) );
 518         }
 519
 520         public function testLanguageVariantsDisabled() {
 521                 $this->setMwGlobals( 'wgDisableLangConversion', true );
 522
 523                 $this->assertSame( [], $this->doQuery( 'languagevariants' ) );
 524         }
 525
 526         /**
 527          * @todo Test a skin with a description that's known to be different in a different language.
 528          *   Vector will do, but it's not installed by default.
 529          *
 530          * @todo Test that an invalid language code doesn't actually try reading any messages
 531          *
 532          * @dataProvider skinsProvider
 533          */
 534         public function testSkins( $code ) {
 535                 $data = $this->doQuery( 'skins', $code !== null ? [ 'siinlanguagecode' => $code ] : [] );
 536
 537                 $expectedAllowed = Skin::getAllowedSkins();
 538                 $expectedDefault = Skin::normalizeKey( 'default' );
 539
 540                 $i = 0;
 541                 foreach ( Skin::getSkinNames() as $name => $displayName ) {
 542                         $this->assertSame( $name, $data[$i]['code'] );
 543
 544                         $msg = wfMessage( "skinname-$name" );
 545                         if ( $code && Language::isValidCode( $code ) ) {
 546                                 $msg->inLanguage( $code );
 547                         } else {
 548                                 $msg->inContentLanguage();
 549                         }
 550                         if ( $msg->exists() ) {
 551                                 $displayName = $msg->text();
 552                         }
 553                         $this->assertSame( $displayName, $data[$i]['name'] );
 554
 555                         if ( !isset( $expectedAllowed[$name] ) ) {
 556                                 $this->assertTrue( $data[$i]['unusable'], "$name must be unusable" );
 557                         }
 558                         if ( $name === $expectedDefault ) {
 559                                 $this->assertTrue( $data[$i]['default'], "$expectedDefault must be default" );
 560                         }
 561                         $i++;
 562                 }
 563         }
 564
 565         public function skinsProvider() {
 566                 return [
 567                         'No language specified' => [ null ],
 568                         'Czech' => [ 'cs' ],
 569                         'Invalid language' => [ '/invalid/' ],
 570                 ];
 571         }
 572
 573         public function testExtensionTags() {
 574                 global $wgParser;
 575
 576                 $expected = array_map(
 577                         function ( $tag ) {
 578                                 return "<$tag>";
 579                         },
 580                         $wgParser->getTags()
 581                 );
 582
 583                 $this->assertSame( $expected, $this->doQuery( 'extensiontags' ) );
 584         }
 585
 586         public function testFunctionHooks() {
 587                 global $wgParser;
 588
 589                 $this->assertSame( $wgParser->getFunctionHooks(), $this->doQuery( 'functionhooks' ) );
 590         }
 591
 592         public function testVariables() {
 593                 $this->assertSame( MagicWord::getVariableIDs(), $this->doQuery( 'variables' ) );
 594         }
 595
 596         public function testProtocols() {
 597                 global $wgUrlProtocols;
 598
 599                 $this->assertSame( $wgUrlProtocols, $this->doQuery( 'protocols' ) );
 600         }
 601
 602         public function testDefaultOptions() {
 603                 $this->assertSame( User::getDefaultOptions(), $this->doQuery( 'defaultoptions' ) );
 604         }
 605
 606         public function testUploadDialog() {
 607                 global $wgUploadDialog;
 608
 609                 $this->assertSame( $wgUploadDialog, $this->doQuery( 'uploaddialog' ) );
 610         }
 611
 612         public function testGetHooks() {
 613                 global $wgHooks;
 614
 615                 // Make sure there's something to report on
 616                 $this->setTemporaryHook( 'somehook',
 617                         function () {
 618                                 return;
 619                         }
 620                 );
 621
 622                 $expectedNames = $wgHooks;
 623                 ksort( $expectedNames );
 624
 625                 $actualNames = array_map(
 626                         function ( $val ) {
 627                                 return $val['name'];
 628                         },
 629                         $this->doQuery( 'showhooks' )
 630                 );
 631
 632                 $this->assertSame( array_keys( $expectedNames ), $actualNames );
 633         }
 634
 635         public function testContinuation() {
 636                 // We make lots and lots of URL protocols that are each 100 bytes
 637                 global $wgAPIMaxResultSize, $wgUrlProtocols;
 638
 639                 $this->setMwGlobals( 'wgUrlProtocols', [] );
 640
 641                 // Just under the limit
 642                 $chunks = $wgAPIMaxResultSize / 100 - 1;
 643
 644                 for ( $i = 0; $i < $chunks; $i++ ) {
 645                         $wgUrlProtocols[] = substr( str_repeat( "$i ", 50 ), 0, 100 );
 646                 }
 647
 648                 $res = $this->doApiRequest( [
 649                         'action' => 'query',
 650                         'meta' => 'siteinfo',
 651                         'siprop' => 'protocols|languages',
 652                 ] );
 653
 654                 $this->assertSame(
 655                         wfMessage( 'apiwarn-truncatedresult', Message::numParam( $wgAPIMaxResultSize ) )
 656                                 ->text(),
 657                         $res[0]['warnings']['result']['warnings']
 658                 );
 659
 660                 $this->assertSame( $wgUrlProtocols, $res[0]['query']['protocols'] );
 661                 $this->assertArrayNotHasKey( 'languages', $res[0] );
 662                 $this->assertTrue( $res[0]['batchcomplete'], 'batchcomplete should be true' );
 663                 $this->assertSame( [ 'siprop' => 'languages', 'continue' => '-||' ], $res[0]['continue'] );
 664         }
 665 }