d0a96db0f9
== Skin::wrapHTML ==
Skin::wrapHTML no longer has to perform any guessing of the
ParserOutput language. Nor does it have to special wiki pages vs
special pages in this regard. Yay, code removal.
== ImagePage ==
On URLs like /wiki/File:Example.jpg, the main output handler is
ImagePage::view. This calls the parent Article::view to handle most of
its output. Article::view obtains the ParserOptions, and then fetches
ParserOutput, and then adds `<div class=mw-parser-output>` and its
metadata to OutputPage.
Before this change, ImagePage::view was creating a wrapper based
on "predicting" what language the ParserOutput will contain. It
couldn't call the new OutputPage::getContentLanguage or some
equivalent as Article::view wouldn't have populated that yet.
This leaky abstraction is fixed by this change as now the `<div>`
from ParserOutput no longer comes with a "please wrap it properly"
contract that Article subclasses couldn't possibly implement correctly
(it coudln't wrap it after the fact because Article::view writes to
OutputPage directly).
RECENT (T310445):
A special case was recently added for file pages about translated SVGs.
For those, we decide which language to use for the "fullMedia" thumb
atop the page. This was recently changed as part of T310445 from a
hardcoded $wgLanguageCode (site content lang) to new problematic
Title::getPageViewLanguage, which tries to guestimate the page
language of the rendered ParserOutput and then gets the preferred
variant for the current user. The motivation for this was to support
language variants but used Title::getPageViewLanguage as a kitchen
sink to achieve that minor side-effect. The only part of this
now-deprecated method that we actually need is
LanguageConverter::getPreferredVariant().
Test plan: Covered by ImagePageTest.
== Skin mainpage-title ==
RECENT (T331095, T298715):
A special case was added to Skin::getTemplateData that powers the
mainpage-title interface message feature. This is empty by default,
but when created via MediaWiki:mainpage-title allows interface admins
to replace the H1 with a custom and localised page heading.
A few months ago, in Ifc9f0a7174, Title::getPageViewLanguage was
applied here to support language variants. Replace with the same
fix as for ImagePage. Revert back to Message::inContentLanguage()
but refactor to inLanguage() via MediaWikiServices::getContentLanguage
so that LanguageConverter::getPreferredVariant can be applied.
== EditPage ==
This was doing similar "predicting" of the ParserOutput language to
create an empty preview placeholder for use by preview.js. Now that
ApiParse (via ParserOutput::getText) returns a usable element without
any secret "you magically know the right class, lang, and dir" contract,
this placeholder is no longer needed.
Test Plan:
* EditPage: Default preview
1. index.php?title=Main_Page&action=edit
2. Show preview
3. Assert <div class="mw-content-ltr mw-parser-output" lang=en dir=ltr>
* EditPage: JS preview
1. Preferences > Editing > Show preview without reload
2. index.php?title=Main_Page&action=edit
3. Show preview
4. Assert <div class="mw-content-ltr mw-parser-output" lang=en dir=ltr>
5. Type something and 'Show preview' again
6. Assert old element gone, new text is shown, and new element
attributes are the same as the above.
== McrUndoAction ==
Same as EditPage basically, but without the JS preview use case.
== DifferenceEngine ==
Test:
1. Open /w/index.php?title=Main_Page&diff=0
(this shows the latest diff, can do manually by viewing
/wiki/Main_Page, click "View history", click "Compare selected revisions")
2. Assert <div class="mw-content-ltr mw-parser-output" lang=en dir=ltr>
3. Open /w/index.php?title=Main_Page&diff=0&action=render
4. Assert <div class="mw-content-ltr mw-parser-output" lang=en dir=ltr>
== Special:ExpandTemplates ==
Test:
1. /wiki/Special:ExpandTemplates
2. Write "Hello".
3. "OK"
4. Assert <div class="mw-content-ltr mw-parser-output" lang=en dir=ltr>
Bug: T341244
Depends-On: Icd9c079f5896ee83d86b9c2699636dc81d25a14c
Depends-On: I4e7484b3b94f1cb6062e7cef9f20626b650bb4b1
Depends-On: I90b88f3b3a3bbeba4f48d118f92f54864997e105
Change-Id: Ib130a055e46764544af0f1a46d2bc2b3a7ee85b7
2248 lines
67 KiB
PHP
2248 lines
67 KiB
PHP
<?php
|
|
|
|
use MediaWiki\Language\RawMessage;
|
|
use MediaWiki\Linker\LinkTarget;
|
|
use MediaWiki\MainConfigNames;
|
|
use MediaWiki\Page\PageIdentity;
|
|
use MediaWiki\Page\PageIdentityValue;
|
|
use MediaWiki\Tests\Unit\DummyServicesTrait;
|
|
use MediaWiki\Title\MalformedTitleException;
|
|
use MediaWiki\Title\Title;
|
|
use MediaWiki\Title\TitleValue;
|
|
use MediaWiki\Utils\MWTimestamp;
|
|
use Wikimedia\Assert\PreconditionException;
|
|
|
|
/**
|
|
* @group Database
|
|
* @group Title
|
|
*/
|
|
class TitleTest extends MediaWikiIntegrationTestCase {
|
|
use DummyServicesTrait;
|
|
use LinkCacheTestTrait;
|
|
|
|
protected function setUp(): void {
|
|
parent::setUp();
|
|
|
|
$this->mergeMwGlobalArrayValue(
|
|
'wgExtraNamespaces',
|
|
[
|
|
12302 => 'TEST-JS',
|
|
12303 => 'TEST-JS_TALK',
|
|
]
|
|
);
|
|
$this->mergeMwGlobalArrayValue(
|
|
'wgNamespaceContentModels',
|
|
[
|
|
12302 => CONTENT_MODEL_JAVASCRIPT,
|
|
]
|
|
);
|
|
|
|
$this->overrideConfigValues( [
|
|
MainConfigNames::AllowUserJs => false,
|
|
MainConfigNames::DefaultLanguageVariant => false,
|
|
MainConfigNames::MetaNamespace => 'Project',
|
|
MainConfigNames::Server => 'https://example.org',
|
|
MainConfigNames::CanonicalServer => 'https://example.org',
|
|
MainConfigNames::ScriptPath => '/w',
|
|
MainConfigNames::Script => '/w/index.php',
|
|
MainConfigNames::ArticlePath => '/wiki/$1',
|
|
MainConfigNames::LanguageCode => 'en',
|
|
// For testSecureAndSplitValid, testSecureAndSplitInvalid
|
|
MainConfigNames::LocalInterwikis => [ 'localtestiw' ],
|
|
] );
|
|
$this->setUserLang( 'en' );
|
|
|
|
// Define valid interwiki prefixes and their configuration
|
|
// DummyServicesTrait::getDummyInterwikiLookup
|
|
$interwikiLookup = $this->getDummyInterwikiLookup( [
|
|
// testSecureAndSplitValid, testSecureAndSplitInvalid
|
|
[ 'iw_prefix' => 'localtestiw', 'iw_url' => 'localtestiw' ],
|
|
[ 'iw_prefix' => 'remotetestiw', 'iw_url' => 'remotetestiw' ],
|
|
|
|
// testSubpages
|
|
'wiki',
|
|
|
|
// testIsValid
|
|
'wikipedia',
|
|
|
|
// testIsValidRedirectTarget
|
|
'acme',
|
|
|
|
// testGetFragmentForURL
|
|
[ 'iw_prefix' => 'de', 'iw_local' => 1 ],
|
|
[ 'iw_prefix' => 'zz', 'iw_local' => 0 ],
|
|
|
|
// Some tests use interwikis - define valid prefixes and their configuration
|
|
// DummyServicesTrait::getDummyInterwikiLookup
|
|
[ 'iw_prefix' => 'acme', 'iw_url' => 'https://acme.test/$1' ],
|
|
[ 'iw_prefix' => 'yy', 'iw_url' => 'https://yy.wiki.test/wiki/$1', 'iw_local' => true ]
|
|
] );
|
|
$this->setService( 'InterwikiLookup', $interwikiLookup );
|
|
}
|
|
|
|
protected function tearDown(): void {
|
|
Title::clearCaches();
|
|
parent::tearDown();
|
|
// delete dummy pages
|
|
$this->getNonexistingTestPage( 'UTest1' );
|
|
$this->getNonexistingTestPage( 'UTest2' );
|
|
}
|
|
|
|
public static function provideInNamespace() {
|
|
return [
|
|
[ 'Main Page', NS_MAIN, true ],
|
|
[ 'Main Page', NS_TALK, false ],
|
|
[ 'Main Page', NS_USER, false ],
|
|
[ 'User:Foo', NS_USER, true ],
|
|
[ 'User:Foo', NS_USER_TALK, false ],
|
|
[ 'User:Foo', NS_TEMPLATE, false ],
|
|
[ 'User_talk:Foo', NS_USER_TALK, true ],
|
|
[ 'User_talk:Foo', NS_USER, false ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideInNamespace
|
|
* @covers MediaWiki\Title\Title::inNamespace
|
|
*/
|
|
public function testInNamespace( $title, $ns, $expectedBool ) {
|
|
$title = Title::newFromText( $title );
|
|
$this->assertEquals( $expectedBool, $title->inNamespace( $ns ) );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::inNamespaces
|
|
*/
|
|
public function testInNamespaces() {
|
|
$mainpage = Title::newFromText( 'Main Page' );
|
|
$this->assertTrue( $mainpage->inNamespaces( NS_MAIN, NS_USER ) );
|
|
$this->assertTrue( $mainpage->inNamespaces( [ NS_MAIN, NS_USER ] ) );
|
|
$this->assertTrue( $mainpage->inNamespaces( [ NS_USER, NS_MAIN ] ) );
|
|
$this->assertFalse( $mainpage->inNamespaces( [ NS_PROJECT, NS_TEMPLATE ] ) );
|
|
}
|
|
|
|
public static function provideHasSubjectNamespace() {
|
|
return [
|
|
[ 'Main Page', NS_MAIN, true ],
|
|
[ 'Main Page', NS_TALK, true ],
|
|
[ 'Main Page', NS_USER, false ],
|
|
[ 'User:Foo', NS_USER, true ],
|
|
[ 'User:Foo', NS_USER_TALK, true ],
|
|
[ 'User:Foo', NS_TEMPLATE, false ],
|
|
[ 'User_talk:Foo', NS_USER_TALK, true ],
|
|
[ 'User_talk:Foo', NS_USER, true ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideHasSubjectNamespace
|
|
* @covers MediaWiki\Title\Title::hasSubjectNamespace
|
|
*/
|
|
public function testHasSubjectNamespace( $title, $ns, $expectedBool ) {
|
|
$title = Title::newFromText( $title );
|
|
$this->assertEquals( $expectedBool, $title->hasSubjectNamespace( $ns ) );
|
|
}
|
|
|
|
public function dataGetContentModel() {
|
|
return [
|
|
[ 'Help:Foo', CONTENT_MODEL_WIKITEXT ],
|
|
[ 'Help:Foo.js', CONTENT_MODEL_WIKITEXT ],
|
|
[ 'Help:Foo/bar.js', CONTENT_MODEL_WIKITEXT ],
|
|
[ 'User:Foo', CONTENT_MODEL_WIKITEXT ],
|
|
[ 'User:Foo.js', CONTENT_MODEL_WIKITEXT ],
|
|
[ 'User:Foo/bar.js', CONTENT_MODEL_JAVASCRIPT ],
|
|
[ 'User:Foo/bar.css', CONTENT_MODEL_CSS ],
|
|
[ 'User talk:Foo/bar.css', CONTENT_MODEL_WIKITEXT ],
|
|
[ 'User:Foo/bar.js.xxx', CONTENT_MODEL_WIKITEXT ],
|
|
[ 'User:Foo/bar.xxx', CONTENT_MODEL_WIKITEXT ],
|
|
[ 'MediaWiki:Foo.js', CONTENT_MODEL_JAVASCRIPT ],
|
|
[ 'MediaWiki:Foo.css', CONTENT_MODEL_CSS ],
|
|
[ 'MediaWiki:Foo/bar.css', CONTENT_MODEL_CSS ],
|
|
[ 'MediaWiki:Foo.JS', CONTENT_MODEL_WIKITEXT ],
|
|
[ 'MediaWiki:Foo.CSS', CONTENT_MODEL_WIKITEXT ],
|
|
[ 'MediaWiki:Foo.css.xxx', CONTENT_MODEL_WIKITEXT ],
|
|
[ 'TEST-JS:Foo', CONTENT_MODEL_JAVASCRIPT ],
|
|
[ 'TEST-JS:Foo.js', CONTENT_MODEL_JAVASCRIPT ],
|
|
[ 'TEST-JS:Foo/bar.js', CONTENT_MODEL_JAVASCRIPT ],
|
|
[ 'TEST-JS_TALK:Foo.js', CONTENT_MODEL_WIKITEXT ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider dataGetContentModel
|
|
* @covers MediaWiki\Title\Title::getContentModel
|
|
*/
|
|
public function testGetContentModel( $title, $expectedModelId ) {
|
|
$title = Title::newFromText( $title );
|
|
$this->assertEquals( $expectedModelId, $title->getContentModel() );
|
|
}
|
|
|
|
/**
|
|
* @dataProvider dataGetContentModel
|
|
* @covers MediaWiki\Title\Title::hasContentModel
|
|
*/
|
|
public function testHasContentModel( $title, $expectedModelId ) {
|
|
$title = Title::newFromText( $title );
|
|
$this->assertTrue( $title->hasContentModel( $expectedModelId ) );
|
|
}
|
|
|
|
public static function provideIsSiteConfigPage() {
|
|
return [
|
|
[ 'Help:Foo', false ],
|
|
[ 'Help:Foo.js', false ],
|
|
[ 'Help:Foo/bar.js', false ],
|
|
[ 'User:Foo', false ],
|
|
[ 'User:Foo.js', false ],
|
|
[ 'User:Foo/bar.js', false ],
|
|
[ 'User:Foo/bar.json', false ],
|
|
[ 'User:Foo/bar.css', false ],
|
|
[ 'User:Foo/bar.JS', false ],
|
|
[ 'User:Foo/bar.JSON', false ],
|
|
[ 'User:Foo/bar.CSS', false ],
|
|
[ 'User talk:Foo/bar.css', false ],
|
|
[ 'User:Foo/bar.js.xxx', false ],
|
|
[ 'User:Foo/bar.xxx', false ],
|
|
[ 'MediaWiki:Foo.js', 'javascript' ],
|
|
[ 'MediaWiki:Foo.json', 'json' ],
|
|
[ 'MediaWiki:Foo.css', 'css' ],
|
|
[ 'MediaWiki:Foo.JS', false ],
|
|
[ 'MediaWiki:Foo.JSON', false ],
|
|
[ 'MediaWiki:Foo.CSS', false ],
|
|
[ 'MediaWiki:Foo/bar.css', 'css' ],
|
|
[ 'MediaWiki:Foo.css.xxx', false ],
|
|
[ 'TEST-JS:Foo', false ],
|
|
[ 'TEST-JS:Foo.js', false ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideIsSiteConfigPage
|
|
* @covers MediaWiki\Title\Title::isSiteConfigPage
|
|
* @covers MediaWiki\Title\Title::isSiteJsConfigPage
|
|
* @covers MediaWiki\Title\Title::isSiteJsonConfigPage
|
|
* @covers MediaWiki\Title\Title::isSiteCssConfigPage
|
|
*/
|
|
public function testSiteConfigPage( $title, $expected ) {
|
|
$title = Title::newFromText( $title );
|
|
|
|
// $expected is either false or the relevant type ('javascript', 'json', 'css')
|
|
$this->assertSame(
|
|
$expected !== false,
|
|
$title->isSiteConfigPage()
|
|
);
|
|
$this->assertSame(
|
|
$expected === 'javascript',
|
|
$title->isSiteJsConfigPage()
|
|
);
|
|
$this->assertSame(
|
|
$expected === 'json',
|
|
$title->isSiteJsonConfigPage()
|
|
);
|
|
$this->assertSame(
|
|
$expected === 'css',
|
|
$title->isSiteCssConfigPage()
|
|
);
|
|
}
|
|
|
|
public static function provideIsUserConfigPage() {
|
|
return [
|
|
[ 'Help:Foo', false ],
|
|
[ 'Help:Foo.js', false ],
|
|
[ 'Help:Foo/bar.js', false ],
|
|
[ 'User:Foo', false ],
|
|
[ 'User:Foo.js', false ],
|
|
[ 'User:Foo/bar.js', 'javascript' ],
|
|
[ 'User:Foo/bar.JS', false ],
|
|
[ 'User:Foo/bar.json', 'json' ],
|
|
[ 'User:Foo/bar.JSON', false ],
|
|
[ 'User:Foo/bar.css', 'css' ],
|
|
[ 'User:Foo/bar.CSS', false ],
|
|
[ 'User talk:Foo/bar.css', false ],
|
|
[ 'User:Foo/bar.js.xxx', false ],
|
|
[ 'User:Foo/bar.xxx', false ],
|
|
[ 'MediaWiki:Foo.js', false ],
|
|
[ 'MediaWiki:Foo.json', false ],
|
|
[ 'MediaWiki:Foo.css', false ],
|
|
[ 'MediaWiki:Foo.JS', false ],
|
|
[ 'MediaWiki:Foo.JSON', false ],
|
|
[ 'MediaWiki:Foo.CSS', false ],
|
|
[ 'MediaWiki:Foo.css.xxx', false ],
|
|
[ 'TEST-JS:Foo', false ],
|
|
[ 'TEST-JS:Foo.js', false ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideIsUserConfigPage
|
|
* @covers MediaWiki\Title\Title::isUserConfigPage
|
|
* @covers MediaWiki\Title\Title::isUserJsConfigPage
|
|
* @covers MediaWiki\Title\Title::isUserJsonConfigPage
|
|
* @covers MediaWiki\Title\Title::isUserCssConfigPage
|
|
*/
|
|
public function testIsUserConfigPage( $title, $expected ) {
|
|
$title = Title::newFromText( $title );
|
|
|
|
// $expected is either false or the relevant type ('javascript', 'json', 'css')
|
|
$this->assertSame(
|
|
$expected !== false,
|
|
$title->isUserConfigPage()
|
|
);
|
|
$this->assertSame(
|
|
$expected === 'javascript',
|
|
$title->isUserJsConfigPage()
|
|
);
|
|
$this->assertSame(
|
|
$expected === 'json',
|
|
$title->isUserJsonConfigPage()
|
|
);
|
|
$this->assertSame(
|
|
$expected === 'css',
|
|
$title->isUserCssConfigPage()
|
|
);
|
|
}
|
|
|
|
public static function provideIsWikitextPage() {
|
|
return [
|
|
[ 'Help:Foo', true ],
|
|
[ 'Help:Foo.js', true ],
|
|
[ 'Help:Foo/bar.js', true ],
|
|
[ 'User:Foo', true ],
|
|
[ 'User:Foo.js', true ],
|
|
[ 'User:Foo/bar.js', false ],
|
|
[ 'User:Foo/bar.json', false ],
|
|
[ 'User:Foo/bar.css', false ],
|
|
[ 'User talk:Foo/bar.css', true ],
|
|
[ 'User:Foo/bar.js.xxx', true ],
|
|
[ 'User:Foo/bar.xxx', true ],
|
|
[ 'MediaWiki:Foo.js', false ],
|
|
[ 'User:Foo/bar.JS', true ],
|
|
[ 'User:Foo/bar.JSON', true ],
|
|
[ 'User:Foo/bar.CSS', true ],
|
|
[ 'MediaWiki:Foo.json', false ],
|
|
[ 'MediaWiki:Foo.css', false ],
|
|
[ 'MediaWiki:Foo.JS', true ],
|
|
[ 'MediaWiki:Foo.JSON', true ],
|
|
[ 'MediaWiki:Foo.CSS', true ],
|
|
[ 'MediaWiki:Foo.css.xxx', true ],
|
|
[ 'TEST-JS:Foo', false ],
|
|
[ 'TEST-JS:Foo.js', false ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideIsWikitextPage
|
|
* @covers MediaWiki\Title\Title::isWikitextPage
|
|
*/
|
|
public function testIsWikitextPage( $title, $expectedBool ) {
|
|
$title = Title::newFromText( $title );
|
|
$this->assertEquals( $expectedBool, $title->isWikitextPage() );
|
|
}
|
|
|
|
public static function provideGetOtherPage() {
|
|
return [
|
|
[ 'Main Page', 'Talk:Main Page' ],
|
|
[ 'Talk:Main Page', 'Main Page' ],
|
|
[ 'Help:Main Page', 'Help talk:Main Page' ],
|
|
[ 'Help talk:Main Page', 'Help:Main Page' ],
|
|
[ 'Special:FooBar', null ],
|
|
[ 'Media:File.jpg', null ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideGetOtherpage
|
|
* @covers MediaWiki\Title\Title::getOtherPage
|
|
*
|
|
* @param string $text
|
|
* @param string|null $expected
|
|
*/
|
|
public function testGetOtherPage( $text, $expected ) {
|
|
if ( $expected === null ) {
|
|
$this->expectException( MWException::class );
|
|
}
|
|
|
|
$title = Title::newFromText( $text );
|
|
$this->assertEquals( $expected, $title->getOtherPage()->getPrefixedText() );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::clearCaches
|
|
*/
|
|
public function testClearCaches() {
|
|
$linkCache = $this->getServiceContainer()->getLinkCache();
|
|
|
|
$title1 = Title::newFromText( 'Foo' );
|
|
$this->addGoodLinkObject( 23, $title1 );
|
|
|
|
Title::clearCaches();
|
|
|
|
$title2 = Title::newFromText( 'Foo' );
|
|
$this->assertNotSame( $title1, $title2, 'title cache should be empty' );
|
|
$this->assertSame( 0, $linkCache->getGoodLinkID( 'Foo' ), 'link cache should be empty' );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getFieldFromPageStore
|
|
*/
|
|
public function testUseCaches() {
|
|
$title1 = Title::makeTitle( NS_MAIN, __METHOD__ . '998724352' );
|
|
$this->addGoodLinkObject( 23, $title1, 7, 0, 42 );
|
|
|
|
// Ensure that getLatestRevID uses the LinkCache even after
|
|
// the article ID is known (T296063#7520023).
|
|
$this->assertSame( 23, $title1->getArticleID() );
|
|
$this->assertSame( 42, $title1->getLatestRevID() );
|
|
}
|
|
|
|
public static function provideGetLinkURL() {
|
|
yield 'Simple' => [
|
|
'/wiki/Goats',
|
|
NS_MAIN,
|
|
'Goats'
|
|
];
|
|
|
|
yield 'Fragment' => [
|
|
'/wiki/Goats#Goatificatiön',
|
|
NS_MAIN,
|
|
'Goats',
|
|
'Goatificatiön'
|
|
];
|
|
|
|
yield 'Fragment only (query is ignored)' => [
|
|
'#Goatificatiön',
|
|
NS_MAIN,
|
|
'',
|
|
'Goatificatiön',
|
|
'',
|
|
[
|
|
'a' => 1,
|
|
]
|
|
];
|
|
|
|
yield 'Unknown interwiki with fragment' => [
|
|
'https://xx.wiki.test/wiki/xyzzy:Goats#Goatificatiön',
|
|
NS_MAIN,
|
|
'Goats',
|
|
'Goatificatiön',
|
|
'xyzzy'
|
|
];
|
|
|
|
yield 'Interwiki with fragment' => [
|
|
'https://acme.test/Goats#Goatificati.C3.B6n',
|
|
NS_MAIN,
|
|
'Goats',
|
|
'Goatificatiön',
|
|
'acme'
|
|
];
|
|
|
|
yield 'Interwiki with query' => [
|
|
'https://acme.test/Goats?a=1&b=blank+blank#Goatificati.C3.B6n',
|
|
NS_MAIN,
|
|
'Goats',
|
|
'Goatificatiön',
|
|
'acme',
|
|
[
|
|
'a' => 1,
|
|
'b' => 'blank blank'
|
|
]
|
|
];
|
|
|
|
yield 'Local interwiki with fragment' => [
|
|
'https://yy.wiki.test/wiki/Goats#Goatificatiön',
|
|
NS_MAIN,
|
|
'Goats',
|
|
'Goatificatiön',
|
|
'yy'
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideGetLinkURL
|
|
*
|
|
* @covers MediaWiki\Title\Title::getLinkURL
|
|
* @covers MediaWiki\Title\Title::getFullURL
|
|
* @covers MediaWiki\Title\Title::getLocalURL
|
|
* @covers MediaWiki\Title\Title::getFragmentForURL
|
|
*/
|
|
public function testGetLinkURL(
|
|
$expected,
|
|
$ns,
|
|
$title,
|
|
$fragment = '',
|
|
$interwiki = '',
|
|
$query = '',
|
|
$query2 = false,
|
|
$proto = false
|
|
) {
|
|
$this->overrideConfigValues( [
|
|
MainConfigNames::Server => 'https://xx.wiki.test',
|
|
MainConfigNames::ArticlePath => '/wiki/$1',
|
|
MainConfigNames::ExternalInterwikiFragmentMode => 'legacy',
|
|
MainConfigNames::FragmentMode => [ 'html5', 'legacy' ]
|
|
] );
|
|
|
|
$title = Title::makeTitle( $ns, $title, $fragment, $interwiki );
|
|
$this->assertSame( $expected, $title->getLinkURL( $query, $query2, $proto ) );
|
|
}
|
|
|
|
public static function provideProperPage() {
|
|
return [
|
|
[ NS_MAIN, 'Test' ],
|
|
[ NS_MAIN, 'User' ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideProperPage
|
|
* @covers MediaWiki\Title\Title::toPageIdentity
|
|
*/
|
|
public function testToPageIdentity( $ns, $text ) {
|
|
$title = Title::makeTitle( $ns, $text );
|
|
|
|
$page = $title->toPageIdentity();
|
|
|
|
$this->assertNotSame( $title, $page );
|
|
$this->assertSame( $title->getId(), $page->getId() );
|
|
$this->assertSame( $title->getNamespace(), $page->getNamespace() );
|
|
$this->assertSame( $title->getDBkey(), $page->getDBkey() );
|
|
$this->assertSame( $title->getWikiId(), $page->getWikiId() );
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideProperPage
|
|
* @covers MediaWiki\Title\Title::toPageRecord
|
|
*/
|
|
public function testToPageRecord( $ns, $text ) {
|
|
$title = Title::makeTitle( $ns, $text );
|
|
$wikiPage = $this->getExistingTestPage( $title );
|
|
|
|
$record = $title->toPageRecord();
|
|
|
|
$this->assertNotSame( $title, $record );
|
|
$this->assertNotSame( $title, $wikiPage );
|
|
|
|
$this->assertSame( $title->getId(), $record->getId() );
|
|
$this->assertSame( $title->getNamespace(), $record->getNamespace() );
|
|
$this->assertSame( $title->getDBkey(), $record->getDBkey() );
|
|
$this->assertSame( $title->getWikiId(), $record->getWikiId() );
|
|
|
|
$this->assertSame( $title->getLatestRevID(), $record->getLatest() );
|
|
$this->assertSame( MWTimestamp::convert( TS_MW, $title->getTouched() ), $record->getTouched() );
|
|
$this->assertSame( $title->isNewPage(), $record->isNew() );
|
|
$this->assertSame( $title->isRedirect(), $record->isRedirect() );
|
|
$this->assertSame( $title->getTouched(), $record->getTouched() );
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideImproperPage
|
|
* @covers MediaWiki\Title\Title::toPageRecord
|
|
*/
|
|
public function testToPageRecord_fail( $ns, $text, $fragment = '', $interwiki = '' ) {
|
|
$title = Title::makeTitle( $ns, $text, $fragment, $interwiki );
|
|
|
|
$this->expectException( PreconditionException::class );
|
|
$title->toPageRecord();
|
|
}
|
|
|
|
public static function provideImproperPage() {
|
|
return [
|
|
[ NS_MAIN, '' ],
|
|
[ NS_MAIN, '<>' ],
|
|
[ NS_MAIN, '|' ],
|
|
[ NS_MAIN, '#' ],
|
|
[ NS_PROJECT, '#test' ],
|
|
[ NS_MAIN, '', 'test', 'acme' ],
|
|
[ NS_MAIN, ' Test' ],
|
|
[ NS_MAIN, '_Test' ],
|
|
[ NS_MAIN, 'Test ' ],
|
|
[ NS_MAIN, 'Test_' ],
|
|
[ NS_MAIN, "Test\nthis" ],
|
|
[ NS_MAIN, "Test\tthis" ],
|
|
[ -33, 'Test' ],
|
|
[ 77663399, 'Test' ],
|
|
|
|
// Valid but can't exist
|
|
[ NS_MAIN, '', 'test' ],
|
|
[ NS_SPECIAL, 'Test' ],
|
|
[ NS_MAIN, 'Test', '', 'acme' ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideImproperPage
|
|
* @covers MediaWiki\Title\Title::getId
|
|
*/
|
|
public function testGetId_fail( $ns, $text, $fragment = '', $interwiki = '' ) {
|
|
$title = Title::makeTitle( $ns, $text, $fragment, $interwiki );
|
|
|
|
$this->expectException( PreconditionException::class );
|
|
$title->getId();
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideImproperPage
|
|
* @covers MediaWiki\Title\Title::getId
|
|
*/
|
|
public function testGetId_fragment() {
|
|
$title = Title::makeTitle( NS_MAIN, 'Test', 'References' );
|
|
|
|
// should not throw
|
|
$this->assertIsInt( $title->getId() );
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideImproperPage
|
|
* @covers MediaWiki\Title\Title::toPageIdentity
|
|
*/
|
|
public function testToPageIdentity_fail( $ns, $text, $fragment = '', $interwiki = '' ) {
|
|
$title = Title::makeTitle( $ns, $text, $fragment, $interwiki );
|
|
|
|
$this->expectException( PreconditionException::class );
|
|
$title->toPageIdentity();
|
|
}
|
|
|
|
public static function provideMakeTitle() {
|
|
yield 'main namespace' => [ 'Foo', NS_MAIN, 'Foo' ];
|
|
yield 'user namespace' => [ 'User:Foo', NS_USER, 'Foo' ];
|
|
yield 'fragment' => [ 'Foo#Section', NS_MAIN, 'Foo', 'Section' ];
|
|
yield 'only fragment' => [ '#Section', NS_MAIN, '', 'Section' ];
|
|
yield 'interwiki' => [ 'acme:Foo', NS_MAIN, 'Foo', '', 'acme' ];
|
|
yield 'normalized underscores' => [ 'Foo Bar', NS_MAIN, 'Foo_Bar' ];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideMakeTitle
|
|
* @covers MediaWiki\Title\Title::makeTitle
|
|
*/
|
|
public function testMakeTitle( $expected, $ns, $text, $fragment = '', $interwiki = '' ) {
|
|
$title = Title::makeTitle( $ns, $text, $fragment, $interwiki );
|
|
|
|
$this->assertTrue( $title->isValid() );
|
|
$this->assertSame( $expected, $title->getFullText() );
|
|
}
|
|
|
|
public static function provideMakeTitle_invalid() {
|
|
yield 'bad namespace' => [ 'Special:Badtitle/NS-1234:Foo', -1234, 'Foo' ];
|
|
yield 'lower case' => [ 'User:foo', NS_USER, 'foo' ];
|
|
yield 'empty' => [ '', NS_MAIN, '' ];
|
|
yield 'bad character' => [ 'Foo|Bar', NS_MAIN, 'Foo|Bar' ];
|
|
yield 'bad interwiki' => [ 'qwerty:Foo', NS_MAIN, 'Foo', '', 'qwerty' ];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideMakeTitle_invalid
|
|
* @covers MediaWiki\Title\Title::makeTitle
|
|
*/
|
|
public function testMakeTitle_invalid( $expected, $ns, $text, $fragment = '', $interwiki = '' ) {
|
|
$title = Title::makeTitle( $ns, $text, $fragment, $interwiki );
|
|
|
|
$this->assertFalse( $title->isValid() );
|
|
$this->assertSame( $expected, $title->getFullText() );
|
|
}
|
|
|
|
public static function provideMakeName() {
|
|
yield 'main namespace' => [ 'Foo', NS_MAIN, 'Foo' ];
|
|
yield 'user namespace' => [ 'User:Foo', NS_USER, 'Foo' ];
|
|
yield 'fragment' => [ 'Foo#Section', NS_MAIN, 'Foo', 'Section' ];
|
|
yield 'only fragment' => [ '#Section', NS_MAIN, '', 'Section' ];
|
|
yield 'interwiki' => [ 'acme:Foo', NS_MAIN, 'Foo', '', 'acme' ];
|
|
yield 'bad namespace' => [ 'Special:Badtitle/NS-1234:Foo', -1234, 'Foo' ];
|
|
yield 'lower case' => [ 'User:foo', NS_USER, 'foo' ];
|
|
yield 'empty' => [ '', NS_MAIN, '' ];
|
|
yield 'bad character' => [ 'Foo|Bar', NS_MAIN, 'Foo|Bar' ];
|
|
yield 'bad interwiki' => [ 'qwerty:Foo', NS_MAIN, 'Foo', '', 'qwerty' ];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideMakeName
|
|
* @covers MediaWiki\Title\Title::makeName
|
|
*/
|
|
public function testMakeName( $expected, $ns, $text, $fragment = '', $interwiki = '' ) {
|
|
$titleName = Title::makeName( $ns, $text, $fragment, $interwiki );
|
|
|
|
$this->assertSame( $expected, $titleName );
|
|
}
|
|
|
|
public static function provideMakeTitleSafe() {
|
|
yield 'main namespace' => [ 'Foo', NS_MAIN, 'Foo' ];
|
|
yield 'user namespace' => [ 'User:Foo', NS_USER, 'Foo' ];
|
|
yield 'fragment' => [ 'Foo#Section', NS_MAIN, 'Foo', 'Section' ];
|
|
yield 'only fragment' => [ '#Section', NS_MAIN, '', 'Section' ];
|
|
yield 'interwiki' => [ 'acme:Foo', NS_MAIN, 'Foo', '', 'acme' ];
|
|
|
|
// Normalize
|
|
yield 'normalized underscores' => [ 'Foo Bar', NS_MAIN, 'Foo_Bar' ];
|
|
yield 'lower case' => [ 'User:Foo', NS_USER, 'foo' ];
|
|
|
|
// Bad interwiki becomes part of the title text. Is this intentional?
|
|
yield 'bad interwiki' => [ 'Qwerty:Foo', NS_MAIN, 'Foo', '', 'qwerty' ];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideMakeTitleSafe
|
|
* @covers MediaWiki\Title\Title::makeTitleSafe
|
|
*/
|
|
public function testMakeTitleSafe( $expected, $ns, $text, $fragment = '', $interwiki = '' ) {
|
|
$title = Title::makeTitleSafe( $ns, $text, $fragment, $interwiki );
|
|
|
|
$this->assertTrue( $title->isValid() );
|
|
$this->assertSame( $expected, $title->getFullText() );
|
|
}
|
|
|
|
public static function provideMakeTitleSafe_invalid() {
|
|
yield 'bad namespace' => [ -1234, 'Foo' ];
|
|
yield 'empty' => [ '', NS_MAIN, '' ];
|
|
yield 'bad character' => [ NS_MAIN, 'Foo|Bar' ];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideMakeTitleSafe_invalid
|
|
* @covers MediaWiki\Title\Title::makeTitleSafe
|
|
*/
|
|
public function testMakeTitleSafe_invalid( $ns, $text, $fragment = '', $interwiki = '' ) {
|
|
$title = Title::makeTitleSafe( $ns, $text, $fragment, $interwiki );
|
|
|
|
$this->assertNull( $title );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getContentModel
|
|
* @covers MediaWiki\Title\Title::setContentModel
|
|
* @covers MediaWiki\Title\Title::uncache
|
|
*/
|
|
public function testSetContentModel() {
|
|
// NOTE: must use newFromText to test behavior of internal instance cache (T281337)
|
|
$title = Title::newFromText( 'Foo' );
|
|
|
|
$title->setContentModel( CONTENT_MODEL_UNKNOWN );
|
|
$this->assertSame( CONTENT_MODEL_UNKNOWN, $title->getContentModel() );
|
|
|
|
// Ensure that the instance we get back from newFromText isn't the modified one.
|
|
$title = Title::newFromText( 'Foo' );
|
|
$this->assertNotSame( CONTENT_MODEL_UNKNOWN, $title->getContentModel() );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::newFromID
|
|
* @covers MediaWiki\Title\Title::newFromRow
|
|
*/
|
|
public function testNewFromId() {
|
|
// First id
|
|
$existingPage1 = $this->getExistingTestPage( 'UTest1' );
|
|
$existingTitle1 = $existingPage1->getTitle();
|
|
$existingId1 = $existingTitle1->getId();
|
|
|
|
$this->assertGreaterThan( 0, $existingId1, 'Existing test page should have a positive id' );
|
|
|
|
$newFromId1 = Title::newFromID( $existingId1 );
|
|
$this->assertInstanceOf( Title::class, $newFromId1, 'newFromID returns a title for an existing id' );
|
|
$this->assertTrue(
|
|
$newFromId1->equals( $existingTitle1 ),
|
|
'newFromID returns the correct title'
|
|
);
|
|
|
|
// Second id
|
|
$existingPage2 = $this->getExistingTestPage( 'UTest2' );
|
|
$existingTitle2 = $existingPage2->getTitle();
|
|
$existingId2 = $existingTitle2->getId();
|
|
|
|
$this->assertGreaterThan( 0, $existingId2, 'Existing test page should have a positive id' );
|
|
|
|
$newFromId2 = Title::newFromID( $existingId2 );
|
|
$this->assertInstanceOf( Title::class, $newFromId2, 'newFromID returns a title for an existing id' );
|
|
$this->assertTrue(
|
|
$newFromId2->equals( $existingTitle2 ),
|
|
'newFromID returns the correct title'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::newFromID
|
|
*/
|
|
public function testNewFromMissingId() {
|
|
// Testing return of null for an id that does not exist
|
|
$maxPageId = (int)$this->db->newSelectQueryBuilder()
|
|
->select( 'max(page_id)' )
|
|
->from( 'page' )
|
|
->caller( __METHOD__ )->fetchField();
|
|
$res = Title::newFromID( $maxPageId + 1 );
|
|
$this->assertNull( $res, 'newFromID returns null for missing ids' );
|
|
}
|
|
|
|
public static function provideValidSecureAndSplit() {
|
|
return [
|
|
[ 'Sandbox' ],
|
|
[ 'A "B"' ],
|
|
[ 'A \'B\'' ],
|
|
[ '.com' ],
|
|
[ '~' ],
|
|
[ '#' ],
|
|
[ '"' ],
|
|
[ '\'' ],
|
|
[ 'Talk:Sandbox' ],
|
|
[ 'Talk:Foo:Sandbox' ],
|
|
[ 'File:Example.svg' ],
|
|
[ 'File_talk:Example.svg' ],
|
|
[ 'Foo/.../Sandbox' ],
|
|
[ 'Sandbox/...' ],
|
|
[ 'A~~' ],
|
|
[ ':A' ],
|
|
// Length is 256 total, but only title part matters
|
|
[ 'Category:' . str_repeat( 'x', 248 ) ],
|
|
[ str_repeat( 'x', 252 ) ],
|
|
// interwiki prefix
|
|
[ 'localtestiw: #anchor' ],
|
|
[ 'localtestiw:' ],
|
|
[ 'localtestiw:foo' ],
|
|
[ 'localtestiw: foo # anchor' ],
|
|
[ 'localtestiw: Talk: Sandbox # anchor' ],
|
|
[ 'remotetestiw:' ],
|
|
[ 'remotetestiw: Talk: # anchor' ],
|
|
[ 'remotetestiw: #bar' ],
|
|
[ 'remotetestiw: Talk:' ],
|
|
[ 'remotetestiw: Talk: Foo' ],
|
|
[ 'localtestiw:remotetestiw:' ],
|
|
[ 'localtestiw:remotetestiw:foo' ]
|
|
];
|
|
}
|
|
|
|
public static function provideInvalidSecureAndSplit() {
|
|
return [
|
|
[ '', 'title-invalid-empty' ],
|
|
[ ':', 'title-invalid-empty' ],
|
|
[ '__ __', 'title-invalid-empty' ],
|
|
[ ' __ ', 'title-invalid-empty' ],
|
|
// Bad characters forbidden regardless of wgLegalTitleChars
|
|
[ 'A [ B', 'title-invalid-characters' ],
|
|
[ 'A ] B', 'title-invalid-characters' ],
|
|
[ 'A { B', 'title-invalid-characters' ],
|
|
[ 'A } B', 'title-invalid-characters' ],
|
|
[ 'A < B', 'title-invalid-characters' ],
|
|
[ 'A > B', 'title-invalid-characters' ],
|
|
[ 'A | B', 'title-invalid-characters' ],
|
|
[ "A \t B", 'title-invalid-characters' ],
|
|
[ "A \n B", 'title-invalid-characters' ],
|
|
// URL encoding
|
|
[ 'A%20B', 'title-invalid-characters' ],
|
|
[ 'A%23B', 'title-invalid-characters' ],
|
|
[ 'A%2523B', 'title-invalid-characters' ],
|
|
// XML/HTML character entity references
|
|
// Note: Commented out because they are not marked invalid by the PHP test as
|
|
// Title::newFromText runs Sanitizer::decodeCharReferencesAndNormalize first.
|
|
// 'A é B',
|
|
// Subject of NS_TALK does not roundtrip to NS_MAIN
|
|
[ 'Talk:File:Example.svg', 'title-invalid-talk-namespace' ],
|
|
// Directory navigation
|
|
[ '.', 'title-invalid-relative' ],
|
|
[ '..', 'title-invalid-relative' ],
|
|
[ './Sandbox', 'title-invalid-relative' ],
|
|
[ '../Sandbox', 'title-invalid-relative' ],
|
|
[ 'Foo/./Sandbox', 'title-invalid-relative' ],
|
|
[ 'Foo/../Sandbox', 'title-invalid-relative' ],
|
|
[ 'Sandbox/.', 'title-invalid-relative' ],
|
|
[ 'Sandbox/..', 'title-invalid-relative' ],
|
|
// Tilde
|
|
[ 'A ~~~ Name', 'title-invalid-magic-tilde' ],
|
|
[ 'A ~~~~ Signature', 'title-invalid-magic-tilde' ],
|
|
[ 'A ~~~~~ Timestamp', 'title-invalid-magic-tilde' ],
|
|
// Length
|
|
[ str_repeat( 'x', 256 ), 'title-invalid-too-long' ],
|
|
// Namespace prefix without actual title
|
|
[ 'Talk:', 'title-invalid-empty' ],
|
|
[ 'Talk:#', 'title-invalid-empty' ],
|
|
[ 'Category: ', 'title-invalid-empty' ],
|
|
[ 'Category: #bar', 'title-invalid-empty' ],
|
|
// interwiki prefix
|
|
[ 'localtestiw: Talk: # anchor', 'title-invalid-empty' ],
|
|
[ 'localtestiw: Talk:', 'title-invalid-empty' ]
|
|
];
|
|
}
|
|
|
|
/**
|
|
* See also mediawiki.Title.test.js
|
|
* @covers MediaWiki\Title\Title::secureAndSplit
|
|
* @dataProvider provideValidSecureAndSplit
|
|
* @note This mainly tests MediaWikiTitleCodec::parseTitle().
|
|
*/
|
|
public function testSecureAndSplitValid( $text ) {
|
|
$this->assertInstanceOf( Title::class, Title::newFromText( $text ), "Valid: $text" );
|
|
}
|
|
|
|
/**
|
|
* See also mediawiki.Title.test.js
|
|
* @covers MediaWiki\Title\Title::secureAndSplit
|
|
* @dataProvider provideInvalidSecureAndSplit
|
|
* @note This mainly tests MediaWikiTitleCodec::parseTitle().
|
|
*/
|
|
public function testSecureAndSplitInvalid( $text, $expectedErrorMessage ) {
|
|
try {
|
|
Title::newFromTextThrow( $text ); // should throw
|
|
$this->fail( "Title::newFromTextThrow should have thrown with $text" );
|
|
} catch ( MalformedTitleException $ex ) {
|
|
$this->assertEquals( $expectedErrorMessage, $ex->getErrorMessage(), "Invalid: $text" );
|
|
}
|
|
}
|
|
|
|
public static function provideSpecialNamesWithAndWithoutParameter() {
|
|
return [
|
|
[ 'Special:Version', null ],
|
|
[ 'Special:Version/', '' ],
|
|
[ 'Special:Version/param', 'param' ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideSpecialNamesWithAndWithoutParameter
|
|
* @covers MediaWiki\Title\Title::fixSpecialName
|
|
*/
|
|
public function testFixSpecialNameRetainsParameter( $text, $expectedParam ) {
|
|
$title = Title::newFromText( $text );
|
|
$fixed = $title->fixSpecialName();
|
|
$stuff = explode( '/', $fixed->getDBkey(), 2 );
|
|
if ( count( $stuff ) == 2 ) {
|
|
$par = $stuff[1];
|
|
} else {
|
|
$par = null;
|
|
}
|
|
$this->assertEquals(
|
|
$expectedParam,
|
|
$par,
|
|
"T33100 regression check: Title->fixSpecialName() should preserve parameter"
|
|
);
|
|
}
|
|
|
|
public function flattenErrorsArray( $errors ) {
|
|
$result = [];
|
|
foreach ( $errors as $error ) {
|
|
$result[] = $error[0];
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
public static function provideGetPageViewLanguage() {
|
|
# Format:
|
|
# - expected
|
|
# - Title name
|
|
# - content language (expected in most cases)
|
|
# - wgLang (on some specific pages)
|
|
# - wgDefaultLanguageVariant
|
|
return [
|
|
[ 'fr', 'Help:I_need_somebody', 'fr', 'fr', false ],
|
|
[ 'es', 'Help:I_need_somebody', 'es', 'zh-tw', false ],
|
|
[ 'zh', 'Help:I_need_somebody', 'zh', 'zh-tw', false ],
|
|
|
|
[ 'es', 'Help:I_need_somebody', 'es', 'zh-tw', 'zh-cn' ],
|
|
[ 'es', 'MediaWiki:About', 'es', 'zh-tw', 'zh-cn' ],
|
|
[ 'es', 'MediaWiki:About/', 'es', 'zh-tw', 'zh-cn' ],
|
|
[ 'de', 'MediaWiki:About/de', 'es', 'zh-tw', 'zh-cn' ],
|
|
[ 'en', 'MediaWiki:Common.js', 'es', 'zh-tw', 'zh-cn' ],
|
|
[ 'en', 'MediaWiki:Common.css', 'es', 'zh-tw', 'zh-cn' ],
|
|
[ 'en', 'User:JohnDoe/Common.js', 'es', 'zh-tw', 'zh-cn' ],
|
|
[ 'en', 'User:JohnDoe/Monobook.css', 'es', 'zh-tw', 'zh-cn' ],
|
|
|
|
[ 'zh-cn', 'Help:I_need_somebody', 'zh', 'zh-tw', 'zh-cn' ],
|
|
[ 'zh', 'MediaWiki:About', 'zh', 'zh-tw', 'zh-cn' ],
|
|
[ 'zh', 'MediaWiki:About/', 'zh', 'zh-tw', 'zh-cn' ],
|
|
[ 'de', 'MediaWiki:About/de', 'zh', 'zh-tw', 'zh-cn' ],
|
|
[ 'zh-cn', 'MediaWiki:About/zh-cn', 'zh', 'zh-tw', 'zh-cn' ],
|
|
[ 'zh-tw', 'MediaWiki:About/zh-tw', 'zh', 'zh-tw', 'zh-cn' ],
|
|
[ 'en', 'MediaWiki:Common.js', 'zh', 'zh-tw', 'zh-cn' ],
|
|
[ 'en', 'MediaWiki:Common.css', 'zh', 'zh-tw', 'zh-cn' ],
|
|
[ 'en', 'User:JohnDoe/Common.js', 'zh', 'zh-tw', 'zh-cn' ],
|
|
[ 'en', 'User:JohnDoe/Monobook.css', 'zh', 'zh-tw', 'zh-cn' ],
|
|
|
|
[ 'zh-tw', 'Special:NewPages', 'es', 'zh-tw', 'zh-cn' ],
|
|
[ 'zh-tw', 'Special:NewPages', 'zh', 'zh-tw', 'zh-cn' ],
|
|
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Superseded by OutputPageTest::testGetJsVarsAboutPageLang
|
|
*
|
|
* @dataProvider provideGetPageViewLanguage
|
|
* @covers MediaWiki\Title\Title::getPageViewLanguage
|
|
*/
|
|
public function testGetPageViewLanguage( $expected, $titleText, $contLang,
|
|
$lang, $variant, $msg = ''
|
|
) {
|
|
// Setup environment for this test
|
|
$this->overrideConfigValues( [
|
|
MainConfigNames::DefaultLanguageVariant => $variant,
|
|
MainConfigNames::AllowUserJs => true,
|
|
] );
|
|
$this->setUserLang( $lang );
|
|
$this->overrideConfigValue( MainConfigNames::LanguageCode, $contLang );
|
|
|
|
$title = Title::newFromText( $titleText );
|
|
$this->assertInstanceOf( Title::class, $title,
|
|
"Test must be passed a valid title text, you gave '$titleText'"
|
|
);
|
|
$this->assertEquals( $expected,
|
|
$title->getPageViewLanguage()->getCode(),
|
|
$msg
|
|
);
|
|
}
|
|
|
|
public static function provideSubpage() {
|
|
// NOTE: avoid constructing Title objects in the provider, since it may access the database.
|
|
return [
|
|
[ 'Foo', 'x', new TitleValue( NS_MAIN, 'Foo/x' ) ],
|
|
[ 'Foo#bar', 'x', new TitleValue( NS_MAIN, 'Foo/x' ) ],
|
|
[ 'User:Foo', 'x', new TitleValue( NS_USER, 'Foo/x' ) ],
|
|
[ 'wiki:User:Foo', 'x', new TitleValue( NS_MAIN, 'User:Foo/x', '', 'wiki' ) ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideSubpage
|
|
* @covers MediaWiki\Title\Title::getSubpage
|
|
*/
|
|
public function testSubpage( $title, $sub, LinkTarget $expected ) {
|
|
$title = Title::newFromText( $title );
|
|
$expected = Title::newFromLinkTarget( $expected );
|
|
$actual = $title->getSubpage( $sub );
|
|
|
|
// NOTE: convert to string for comparison
|
|
$this->assertSame( $expected->getPrefixedText(), $actual->getPrefixedText(), 'text form' );
|
|
$this->assertTrue( $expected->equals( $actual ), 'Title equality' );
|
|
}
|
|
|
|
public static function provideIsAlwaysKnown() {
|
|
return [
|
|
[ 'Some nonexistent page' . wfRandomString(), false ],
|
|
[ 'Some existent page', false, true ],
|
|
[ '#test', true ],
|
|
[ 'Special:BlankPage', true ],
|
|
[ 'Special:SomeNonexistentSpecialPage', false ],
|
|
[ 'MediaWiki:Parentheses', true ],
|
|
[ 'MediaWiki:Some nonexistent message', false ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::isAlwaysKnown
|
|
* @dataProvider provideIsAlwaysKnown
|
|
* @param string $page
|
|
* @param bool $isKnown
|
|
* @param bool $createIfNotExists
|
|
*/
|
|
public function testIsAlwaysKnown( $page, $isKnown, bool $createIfNotExists = false ) {
|
|
if ( $createIfNotExists ) {
|
|
$this->getExistingTestPage( $page );
|
|
}
|
|
$title = Title::newFromText( $page );
|
|
$this->assertEquals( $isKnown, $title->isAlwaysKnown() );
|
|
}
|
|
|
|
public static function provideIsValid() {
|
|
return [
|
|
[ Title::makeTitle( NS_MAIN, '' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, '<>' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, '|' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, '#' ), false ],
|
|
[ Title::makeTitle( NS_PROJECT, '#' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, '', 'test' ), true ],
|
|
[ Title::makeTitle( NS_PROJECT, '#test' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, '', 'test', 'wikipedia' ), true ],
|
|
[ Title::makeTitle( NS_MAIN, 'Test', '', 'wikipedia' ), true ],
|
|
[ Title::makeTitle( NS_MAIN, 'Test' ), true ],
|
|
[ Title::makeTitle( NS_SPECIAL, 'Test' ), true ],
|
|
[ Title::makeTitle( NS_MAIN, ' Test' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, '_Test' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, 'Test ' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, 'Test_' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, "Test\nthis" ), false ],
|
|
[ Title::makeTitle( NS_MAIN, "Test\tthis" ), false ],
|
|
[ Title::makeTitle( -33, 'Test' ), false ],
|
|
[ Title::makeTitle( 77663399, 'Test' ), false ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::isValid
|
|
* @dataProvider provideIsValid
|
|
* @param Title $title
|
|
* @param bool $isValid
|
|
*/
|
|
public function testIsValid( Title $title, $isValid ) {
|
|
$this->assertEquals( $isValid, $title->isValid(), $title->getFullText() );
|
|
}
|
|
|
|
public static function provideIsValidRedirectTarget() {
|
|
return [
|
|
[ Title::makeTitle( NS_MAIN, '' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, '', 'test' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, 'Foo', 'test' ), true ],
|
|
[ Title::makeTitle( NS_MAIN, '<>' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, '_' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, 'Test', '', 'acme' ), true ],
|
|
[ Title::makeTitle( NS_SPECIAL, 'UserLogout' ), false ],
|
|
[ Title::makeTitle( NS_SPECIAL, 'RecentChanges' ), true ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::isValidRedirectTarget
|
|
* @dataProvider provideIsValidRedirectTarget
|
|
* @param Title $title
|
|
* @param bool $isValid
|
|
*/
|
|
public function testIsValidRedirectTarget( Title $title, $isValid ) {
|
|
// InterwikiLookup is configured in setUp()
|
|
$this->assertEquals( $isValid, $title->isValidRedirectTarget(), $title->getFullText() );
|
|
}
|
|
|
|
public static function provideCanExist() {
|
|
return [
|
|
[ Title::makeTitle( NS_MAIN, '' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, '<>' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, '|' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, '#' ), false ],
|
|
[ Title::makeTitle( NS_PROJECT, '#test' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, '', 'test', 'acme' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, 'Test' ), true ],
|
|
[ Title::makeTitle( NS_MAIN, ' Test' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, '_Test' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, 'Test ' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, 'Test_' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, "Test\nthis" ), false ],
|
|
[ Title::makeTitle( NS_MAIN, "Test\tthis" ), false ],
|
|
[ Title::makeTitle( -33, 'Test' ), false ],
|
|
[ Title::makeTitle( 77663399, 'Test' ), false ],
|
|
|
|
// Valid but can't exist
|
|
[ Title::makeTitle( NS_MAIN, '', 'test' ), false ],
|
|
[ Title::makeTitle( NS_SPECIAL, 'Test' ), false ],
|
|
[ Title::makeTitle( NS_MAIN, 'Test', '', 'acme' ), false ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::canExist
|
|
* @dataProvider provideCanExist
|
|
* @param Title $title
|
|
* @param bool $canExist
|
|
*/
|
|
public function testCanExist( Title $title, $canExist ) {
|
|
$this->assertEquals( $canExist, $title->canExist(), $title->getFullText() );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::isAlwaysKnown
|
|
*/
|
|
public function testIsAlwaysKnownOnInterwiki() {
|
|
$title = Title::makeTitle( NS_MAIN, 'Interwiki link', '', 'externalwiki' );
|
|
$this->assertTrue( $title->isAlwaysKnown() );
|
|
}
|
|
|
|
public static function provideGetSkinFromConfigSubpage() {
|
|
return [
|
|
[ 'User:Foo', '' ],
|
|
[ 'User:Foo.css', '' ],
|
|
[ 'User:Foo/', '' ],
|
|
[ 'User:Foo/bar', '' ],
|
|
[ 'User:Foo./bar', '' ],
|
|
[ 'User:Foo/bar.', 'bar' ],
|
|
[ 'User:Foo/bar.css', 'bar' ],
|
|
[ '/bar.css', '' ],
|
|
[ '//bar.css', 'bar' ],
|
|
[ '.css', '' ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideGetSkinFromConfigSubpage
|
|
* @covers MediaWiki\Title\Title::getSkinFromConfigSubpage
|
|
*/
|
|
public function testGetSkinFromConfigSubpage( $title, $expected ) {
|
|
$title = Title::newFromText( $title );
|
|
$this->assertSame( $expected, $title->getSkinFromConfigSubpage() );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getWikiId
|
|
*/
|
|
public function testGetWikiId() {
|
|
$title = Title::newFromText( 'Foo' );
|
|
$this->assertFalse( $title->getWikiId() );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getFragment
|
|
* @covers MediaWiki\Title\Title::getFragment
|
|
* @covers MediaWiki\Title\Title::uncache
|
|
*/
|
|
public function testSetFragment() {
|
|
// NOTE: must use newFromText to test behavior of internal instance cache (T281337)
|
|
$title = Title::newFromText( 'Foo' );
|
|
|
|
$title->setFragment( '#Xyzzy' );
|
|
$this->assertSame( 'Xyzzy', $title->getFragment() );
|
|
|
|
// Ensure that the instance we get back from newFromText isn't the modified one.
|
|
$title = Title::newFromText( 'Foo' );
|
|
$this->assertNotSame( 'Xyzzy', $title->getFragment() );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::__clone
|
|
*/
|
|
public function testClone() {
|
|
// NOTE: must use newFromText to test behavior of internal instance cache (T281337)
|
|
$title = Title::newFromText( 'Foo' );
|
|
|
|
$clone = clone $title;
|
|
$clone->setFragment( '#Xyzzy' );
|
|
|
|
// Ensure that the instance we get back from newFromText is the original one
|
|
$title2 = Title::newFromText( 'Foo' );
|
|
$this->assertSame( $title, $title2 );
|
|
}
|
|
|
|
public static function provideBaseTitleCases() {
|
|
return [
|
|
# Namespace, Title text, expected base
|
|
[ NS_USER, 'John_Doe', 'John Doe' ],
|
|
[ NS_USER, 'John_Doe/subOne/subTwo', 'John Doe/subOne' ],
|
|
[ NS_USER, 'Foo / Bar / Baz', 'Foo / Bar ' ],
|
|
[ NS_USER, 'Foo/', 'Foo' ],
|
|
[ NS_USER, 'Foo/Bar/', 'Foo/Bar' ],
|
|
[ NS_USER, '/', '/' ],
|
|
[ NS_USER, '//', '/' ],
|
|
[ NS_USER, '/oops/', '/oops' ],
|
|
[ NS_USER, '/indeed', '/indeed' ],
|
|
[ NS_USER, '//indeed', '/' ],
|
|
[ NS_USER, '/Ramba/Zamba/Mamba/', '/Ramba/Zamba/Mamba' ],
|
|
[ NS_USER, '//x//y//z//', '//x//y//z/' ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideBaseTitleCases
|
|
* @covers MediaWiki\Title\Title::getBaseText
|
|
*/
|
|
public function testGetBaseText( $namespace, $title, $expected ) {
|
|
$title = Title::makeTitle( $namespace, $title );
|
|
$this->assertSame( $expected, $title->getBaseText() );
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideBaseTitleCases
|
|
* @covers MediaWiki\Title\Title::getBaseTitle
|
|
*/
|
|
public function testGetBaseTitle( $namespace, $title, $expected ) {
|
|
$title = Title::makeTitle( $namespace, $title );
|
|
$base = $title->getBaseTitle();
|
|
$this->assertTrue( $base->isValid() );
|
|
$this->assertTrue(
|
|
$base->equals( Title::makeTitleSafe( $title->getNamespace(), $expected ) )
|
|
);
|
|
}
|
|
|
|
public static function provideRootTitleCases() {
|
|
return [
|
|
# Namespace, Title, expected base
|
|
[ NS_USER, 'John_Doe', 'John Doe' ],
|
|
[ NS_USER, 'John_Doe/subOne/subTwo', 'John Doe' ],
|
|
[ NS_USER, 'Foo / Bar / Baz', 'Foo ' ],
|
|
[ NS_USER, 'Foo/', 'Foo' ],
|
|
[ NS_USER, 'Foo/Bar/', 'Foo' ],
|
|
[ NS_USER, '/', '/' ],
|
|
[ NS_USER, '//', '/' ],
|
|
[ NS_USER, '/oops/', '/oops' ],
|
|
[ NS_USER, '/Ramba/Zamba/Mamba/', '/Ramba' ],
|
|
[ NS_USER, '//x//y//z//', '//x' ],
|
|
[ NS_TALK, '////', '///' ],
|
|
[ NS_TEMPLATE, '////', '///' ],
|
|
[ NS_TEMPLATE, 'Foo////', 'Foo' ],
|
|
[ NS_TEMPLATE, 'Foo////Bar', 'Foo' ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideRootTitleCases
|
|
* @covers MediaWiki\Title\Title::getRootText
|
|
*/
|
|
public function testGetRootText( $namespace, $title, $expected ) {
|
|
$title = Title::makeTitle( $namespace, $title );
|
|
$this->assertEquals( $expected, $title->getRootText() );
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideRootTitleCases
|
|
* @covers MediaWiki\Title\Title::getRootTitle
|
|
*/
|
|
public function testGetRootTitle( $namespace, $title, $expected ) {
|
|
$title = Title::makeTitle( $namespace, $title );
|
|
$root = $title->getRootTitle();
|
|
$this->assertTrue( $root->isValid() );
|
|
$this->assertTrue(
|
|
$root->equals( Title::makeTitleSafe( $title->getNamespace(), $expected ) )
|
|
);
|
|
}
|
|
|
|
public static function provideSubpageTitleCases() {
|
|
return [
|
|
# Namespace, Title, expected base
|
|
[ NS_USER, 'John_Doe', 'John Doe' ],
|
|
[ NS_USER, 'John_Doe/subOne/subTwo', 'subTwo' ],
|
|
[ NS_USER, 'John_Doe/subOne', 'subOne' ],
|
|
[ NS_USER, '/', '/' ],
|
|
[ NS_USER, '//', '' ],
|
|
[ NS_USER, '/oops/', '' ],
|
|
[ NS_USER, '/indeed', '/indeed' ],
|
|
[ NS_USER, '//indeed', 'indeed' ],
|
|
[ NS_USER, '/Ramba/Zamba/Mamba/', '' ],
|
|
[ NS_USER, '//x//y//z//', '' ],
|
|
[ NS_TEMPLATE, 'Foo', 'Foo' ],
|
|
[ NS_CATEGORY, 'Foo', 'Foo' ],
|
|
[ NS_MAIN, 'Bar', 'Bar' ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideSubpageTitleCases
|
|
* @covers MediaWiki\Title\Title::getSubpageText
|
|
*/
|
|
public function testGetSubpageText( $namespace, $title, $expected ) {
|
|
$title = Title::makeTitle( $namespace, $title );
|
|
$this->assertEquals( $expected, $title->getSubpageText() );
|
|
}
|
|
|
|
public static function provideGetTitleValue() {
|
|
return [
|
|
[ 'Foo' ],
|
|
[ 'Foo#bar' ],
|
|
[ 'User:Hansi_Maier' ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getTitleValue
|
|
* @dataProvider provideGetTitleValue
|
|
*/
|
|
public function testGetTitleValue( $text ) {
|
|
$title = Title::newFromText( $text );
|
|
$value = $title->getTitleValue();
|
|
|
|
$dbkey = str_replace( ' ', '_', $value->getText() );
|
|
$this->assertEquals( $title->getDBkey(), $dbkey );
|
|
$this->assertEquals( $title->getNamespace(), $value->getNamespace() );
|
|
$this->assertEquals( $title->getFragment(), $value->getFragment() );
|
|
}
|
|
|
|
public static function provideGetFragment() {
|
|
return [
|
|
[ 'Foo', '' ],
|
|
[ 'Foo#bar', 'bar' ],
|
|
[ 'Foo#bär', 'bär' ],
|
|
|
|
// Inner whitespace is normalized
|
|
[ 'Foo#bar_bar', 'bar bar' ],
|
|
[ 'Foo#bar bar', 'bar bar' ],
|
|
[ 'Foo#bar bar', 'bar bar' ],
|
|
|
|
// Leading whitespace is kept, trailing whitespace is trimmed.
|
|
// XXX: Is this really want we want?
|
|
[ 'Foo#_bar_bar_', ' bar bar' ],
|
|
[ 'Foo# bar bar ', ' bar bar' ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getFragment
|
|
* @dataProvider provideGetFragment
|
|
*
|
|
* @param string $full
|
|
* @param string $fragment
|
|
*/
|
|
public function testGetFragment( $full, $fragment ) {
|
|
$title = Title::newFromText( $full );
|
|
$this->assertEquals( $fragment, $title->getFragment() );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::exists
|
|
*/
|
|
public function testExists() {
|
|
$title = Title::makeTitle( NS_PROJECT, 'New page' );
|
|
$linkCache = $this->getServiceContainer()->getLinkCache();
|
|
|
|
$article = new Article( $title );
|
|
$page = $article->getPage();
|
|
$page->doUserEditContent(
|
|
new WikitextContent( 'Some [[link]]' ),
|
|
$this->getTestSysop()->getUser(),
|
|
'summary'
|
|
);
|
|
|
|
// Tell Title it doesn't know whether it exists
|
|
$title->mArticleID = -1;
|
|
|
|
// Tell the link cache it doesn't exist when it really does
|
|
$linkCache->clearLink( $title );
|
|
$linkCache->addBadLinkObj( $title );
|
|
|
|
$this->assertFalse(
|
|
$title->exists(),
|
|
'exists() should rely on link cache unless READ_LATEST is used'
|
|
);
|
|
$this->assertTrue(
|
|
$title->exists( Title::READ_LATEST ),
|
|
'exists() should re-query database when READ_LATEST is used'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getArticleID
|
|
* @covers MediaWiki\Title\Title::getId
|
|
*/
|
|
public function testGetArticleID() {
|
|
$title = Title::makeTitle( NS_PROJECT, __METHOD__ );
|
|
$this->assertSame( 0, $title->getArticleID() );
|
|
$this->assertSame( $title->getArticleID(), $title->getId() );
|
|
|
|
$article = new Article( $title );
|
|
$page = $article->getPage();
|
|
$page->doUserEditContent(
|
|
new WikitextContent( 'Some [[link]]' ),
|
|
$this->getTestSysop()->getUser(),
|
|
'summary'
|
|
);
|
|
|
|
$this->assertGreaterThan( 0, $title->getArticleID() );
|
|
$this->assertSame( $title->getArticleID(), $title->getId() );
|
|
}
|
|
|
|
public static function provideNonProperTitles() {
|
|
return [
|
|
'section link' => [ Title::makeTitle( NS_MAIN, '', 'Section' ) ],
|
|
'empty' => [ Title::makeTitle( NS_MAIN, '' ) ],
|
|
'bad chars' => [ Title::makeTitle( NS_MAIN, '_|_' ) ],
|
|
'empty in namspace' => [ Title::makeTitle( NS_USER, '' ) ],
|
|
'special' => [ Title::makeTitle( NS_SPECIAL, 'RecentChanges' ) ],
|
|
'interwiki' => [ Title::makeTitle( NS_MAIN, 'Test', '', 'acme' ) ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideNonProperTitles
|
|
* @covers MediaWiki\Title\Title::getArticleID
|
|
*/
|
|
public function testGetArticleIDFromNonProperTitle( $title ) {
|
|
// make sure nothing explodes
|
|
$this->assertSame( 0, $title->getArticleID() );
|
|
}
|
|
|
|
public static function provideCanHaveTalkPage() {
|
|
return [
|
|
'User page has talk page' => [
|
|
Title::makeTitle( NS_USER, 'Jane' ), true
|
|
],
|
|
'Talke page has talk page' => [
|
|
Title::makeTitle( NS_TALK, 'Foo' ), true
|
|
],
|
|
'Special page cannot have talk page' => [
|
|
Title::makeTitle( NS_SPECIAL, 'Thing' ), false
|
|
],
|
|
'Virtual namespace cannot have talk page' => [
|
|
Title::makeTitle( NS_MEDIA, 'Kitten.jpg' ), false
|
|
],
|
|
'Relative link has no talk page' => [
|
|
Title::makeTitle( NS_MAIN, '', 'Kittens' ), false
|
|
],
|
|
'Interwiki link has no talk page' => [
|
|
Title::makeTitle( NS_MAIN, 'Kittens', '', 'acme' ), false
|
|
],
|
|
];
|
|
}
|
|
|
|
public static function provideGetTalkPage_good() {
|
|
return [
|
|
[ Title::makeTitle( NS_MAIN, 'Test' ), Title::makeTitle( NS_TALK, 'Test' ) ],
|
|
[ Title::makeTitle( NS_TALK, 'Test' ), Title::makeTitle( NS_TALK, 'Test' ) ],
|
|
];
|
|
}
|
|
|
|
public static function provideGetTalkPage_bad() {
|
|
return [
|
|
[ Title::makeTitle( NS_SPECIAL, 'Test' ) ],
|
|
[ Title::makeTitle( NS_MEDIA, 'Test' ) ],
|
|
];
|
|
}
|
|
|
|
public static function provideGetTalkPage_broken() {
|
|
// These cases *should* be bad, but are not treated as bad, for backwards compatibility.
|
|
// See discussion on T227817.
|
|
return [
|
|
[
|
|
Title::makeTitle( NS_MAIN, '', 'Kittens' ),
|
|
Title::makeTitle( NS_TALK, '' ), // Section is lost!
|
|
false,
|
|
],
|
|
[
|
|
Title::makeTitle( NS_MAIN, 'Kittens', '', 'acme' ),
|
|
Title::makeTitle( NS_TALK, 'Kittens', '' ), // Interwiki prefix is lost!
|
|
true,
|
|
],
|
|
];
|
|
}
|
|
|
|
public static function provideGetSubjectPage_good() {
|
|
return [
|
|
[ Title::makeTitle( NS_TALK, 'Test' ), Title::makeTitle( NS_MAIN, 'Test' ) ],
|
|
[ Title::makeTitle( NS_MAIN, 'Test' ), Title::makeTitle( NS_MAIN, 'Test' ) ],
|
|
];
|
|
}
|
|
|
|
public static function provideGetOtherPage_good() {
|
|
return [
|
|
[ Title::makeTitle( NS_MAIN, 'Test' ), Title::makeTitle( NS_TALK, 'Test' ) ],
|
|
[ Title::makeTitle( NS_TALK, 'Test' ), Title::makeTitle( NS_MAIN, 'Test' ) ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideCanHaveTalkPage
|
|
* @covers MediaWiki\Title\Title::canHaveTalkPage
|
|
*
|
|
* @param Title $title
|
|
* @param bool $expected
|
|
*/
|
|
public function testCanHaveTalkPage( Title $title, $expected ) {
|
|
$actual = $title->canHaveTalkPage();
|
|
$this->assertSame( $expected, $actual, $title->getPrefixedDBkey() );
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideGetTalkPage_good
|
|
* @covers MediaWiki\Title\Title::getTalkPageIfDefined
|
|
*/
|
|
public function testGetTalkPage_good( Title $title, Title $expected ) {
|
|
$actual = $title->getTalkPage();
|
|
$this->assertTrue( $expected->equals( $actual ), $title->getPrefixedDBkey() );
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideGetTalkPage_bad
|
|
* @covers MediaWiki\Title\Title::getTalkPageIfDefined
|
|
*/
|
|
public function testGetTalkPage_bad( Title $title ) {
|
|
$this->expectException( MWException::class );
|
|
$title->getTalkPage();
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideGetTalkPage_broken
|
|
* @covers MediaWiki\Title\Title::getTalkPageIfDefined
|
|
*/
|
|
public function testGetTalkPage_broken( Title $title, Title $expected, $valid ) {
|
|
// NOTE: Eventually we want to throw in this case. But while there is still code that
|
|
// calls this method without checking, we want to avoid fatal errors.
|
|
// See discussion on T227817.
|
|
$result = @$title->getTalkPage();
|
|
$this->assertTrue( $expected->equals( $result ) );
|
|
$this->assertSame( $valid, $result->isValid() );
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideGetTalkPage_good
|
|
* @covers MediaWiki\Title\Title::getTalkPageIfDefined
|
|
*/
|
|
public function testGetTalkPageIfDefined_good( Title $title, Title $expected ) {
|
|
$actual = $title->getTalkPageIfDefined();
|
|
$this->assertNotNull( $actual, $title->getPrefixedDBkey() );
|
|
$this->assertTrue( $expected->equals( $actual ), $title->getPrefixedDBkey() );
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideGetTalkPage_bad
|
|
* @covers MediaWiki\Title\Title::getTalkPageIfDefined
|
|
*/
|
|
public function testGetTalkPageIfDefined_bad( Title $title ) {
|
|
$talk = $title->getTalkPageIfDefined();
|
|
$this->assertNull(
|
|
$talk,
|
|
$title->getPrefixedDBkey()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideGetSubjectPage_good
|
|
* @covers MediaWiki\Title\Title::getSubjectPage
|
|
*/
|
|
public function testGetSubjectPage_good( Title $title, Title $expected ) {
|
|
$actual = $title->getSubjectPage();
|
|
$this->assertTrue( $expected->equals( $actual ), $title->getPrefixedDBkey() );
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideGetOtherPage_good
|
|
* @covers MediaWiki\Title\Title::getOtherPage
|
|
*/
|
|
public function testGetOtherPage_good( Title $title, Title $expected ) {
|
|
$actual = $title->getOtherPage();
|
|
$this->assertTrue( $expected->equals( $actual ), $title->getPrefixedDBkey() );
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideGetTalkPage_bad
|
|
* @covers MediaWiki\Title\Title::getOtherPage
|
|
*/
|
|
public function testGetOtherPage_bad( Title $title ) {
|
|
$this->expectException( MWException::class );
|
|
$title->getOtherPage();
|
|
}
|
|
|
|
public static function provideIsMovable() {
|
|
return [
|
|
'Simple title' => [ 'Foo', true ],
|
|
// @todo Should these next two really be true?
|
|
'Empty name' => [ Title::makeTitle( NS_MAIN, '' ), true ],
|
|
'Invalid name' => [ Title::makeTitle( NS_MAIN, '<' ), true ],
|
|
'Interwiki' => [ Title::makeTitle( NS_MAIN, 'Test', '', 'otherwiki' ), false ],
|
|
'Special page' => [ 'Special:FooBar', false ],
|
|
'Aborted by hook' => [ 'Hooked in place', false,
|
|
static function ( Title $title, &$result ) {
|
|
$result = false;
|
|
}
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider provideIsMovable
|
|
* @covers MediaWiki\Title\Title::isMovable
|
|
*
|
|
* @param string|Title $title
|
|
* @param bool $expected
|
|
* @param callable|null $hookCallback For TitleIsMovable
|
|
*/
|
|
public function testIsMovable( $title, $expected, $hookCallback = null ) {
|
|
if ( $hookCallback ) {
|
|
$this->setTemporaryHook( 'TitleIsMovable', $hookCallback );
|
|
}
|
|
if ( is_string( $title ) ) {
|
|
$title = Title::newFromText( $title );
|
|
}
|
|
|
|
$this->assertSame( $expected, $title->isMovable() );
|
|
}
|
|
|
|
public static function provideGetPrefixedText() {
|
|
return [
|
|
// ns = 0
|
|
[
|
|
Title::makeTitle( NS_MAIN, 'Foo bar' ),
|
|
'Foo bar'
|
|
],
|
|
// ns = 2
|
|
[
|
|
Title::makeTitle( NS_USER, 'Foo bar' ),
|
|
'User:Foo bar'
|
|
],
|
|
// ns = 3
|
|
[
|
|
Title::makeTitle( NS_USER_TALK, 'Foo bar' ),
|
|
'User talk:Foo bar'
|
|
],
|
|
// fragment not included
|
|
[
|
|
Title::makeTitle( NS_MAIN, 'Foo bar', 'fragment' ),
|
|
'Foo bar'
|
|
],
|
|
// ns = -2
|
|
[
|
|
Title::makeTitle( NS_MEDIA, 'Foo bar' ),
|
|
'Media:Foo bar'
|
|
],
|
|
// non-existent namespace
|
|
[
|
|
Title::makeTitle( 100777, 'Foo bar' ),
|
|
'Special:Badtitle/NS100777:Foo bar'
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getPrefixedText
|
|
* @dataProvider provideGetPrefixedText
|
|
*/
|
|
public function testGetPrefixedText( Title $title, $expected ) {
|
|
$this->assertEquals( $expected, $title->getPrefixedText() );
|
|
}
|
|
|
|
public static function provideGetPrefixedDBKey() {
|
|
return [
|
|
// ns = 0
|
|
[
|
|
Title::makeTitle( NS_MAIN, 'Foo_bar' ),
|
|
'Foo_bar'
|
|
],
|
|
// ns = 2
|
|
[
|
|
Title::makeTitle( NS_USER, 'Foo_bar' ),
|
|
'User:Foo_bar'
|
|
],
|
|
// ns = 3
|
|
[
|
|
Title::makeTitle( NS_USER_TALK, 'Foo_bar' ),
|
|
'User_talk:Foo_bar'
|
|
],
|
|
// fragment not included
|
|
[
|
|
Title::makeTitle( NS_MAIN, 'Foo_bar', 'fragment' ),
|
|
'Foo_bar'
|
|
],
|
|
// ns = -2
|
|
[
|
|
Title::makeTitle( NS_MEDIA, 'Foo_bar' ),
|
|
'Media:Foo_bar'
|
|
],
|
|
// non-existent namespace
|
|
[
|
|
Title::makeTitle( 100777, 'Foo_bar' ),
|
|
'Special:Badtitle/NS100777:Foo_bar'
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getPrefixedDBKey
|
|
* @dataProvider provideGetPrefixedDBKey
|
|
*/
|
|
public function testGetPrefixedDBKey( Title $title, $expected ) {
|
|
$this->assertEquals( $expected, $title->getPrefixedDBkey() );
|
|
}
|
|
|
|
public static function provideGetFragmentForURL() {
|
|
return [
|
|
[ 'Foo', '' ],
|
|
[ 'Foo#ümlåût', '#ümlåût' ],
|
|
[ 'de:Foo#Bå®', '#Bå®' ],
|
|
[ 'zz:Foo#тест', '#.D1.82.D0.B5.D1.81.D1.82' ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getFragmentForURL
|
|
* @dataProvider provideGetFragmentForURL
|
|
*
|
|
* @param string $titleStr
|
|
* @param string $expected
|
|
*/
|
|
public function testGetFragmentForURL( $titleStr, $expected ) {
|
|
$this->overrideConfigValues( [
|
|
MainConfigNames::FragmentMode => [ 'html5' ],
|
|
MainConfigNames::ExternalInterwikiFragmentMode => 'legacy',
|
|
] );
|
|
// InterwikiLookup is configured in setUp()
|
|
|
|
$title = Title::newFromText( $titleStr );
|
|
self::assertEquals( $expected, $title->getFragmentForURL() );
|
|
}
|
|
|
|
public static function provideIsRawHtmlMessage() {
|
|
return [
|
|
[ 'MediaWiki:Foobar', true ],
|
|
[ 'MediaWiki:Foo bar', true ],
|
|
[ 'MediaWiki:Foo-bar', true ],
|
|
[ 'MediaWiki:foo bar', true ],
|
|
[ 'MediaWiki:foo-bar', true ],
|
|
[ 'MediaWiki:foobar', true ],
|
|
[ 'MediaWiki:some-other-message', false ],
|
|
[ 'Main Page', false ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::isRawHtmlMessage
|
|
* @dataProvider provideIsRawHtmlMessage
|
|
*/
|
|
public function testIsRawHtmlMessage( $textForm, $expected ) {
|
|
$this->overrideConfigValue(
|
|
MainConfigNames::RawHtmlMessages,
|
|
[
|
|
'foobar',
|
|
'foo_bar',
|
|
'foo-bar',
|
|
]
|
|
);
|
|
|
|
$title = Title::newFromText( $textForm );
|
|
$this->assertSame( $expected, $title->isRawHtmlMessage() );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::newMainPage
|
|
*/
|
|
public function testNewMainPage() {
|
|
$mock = $this->createMock( MessageCache::class );
|
|
$mock->method( 'get' )->willReturn( 'Foresheet' );
|
|
$mock->method( 'transform' )->willReturn( 'Foresheet' );
|
|
|
|
$this->setService( 'MessageCache', $mock );
|
|
|
|
$this->assertSame(
|
|
'Foresheet',
|
|
Title::newMainPage()->getText()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Regression test for T297571
|
|
*
|
|
* @covers MediaWiki\Title\Title::newMainPage
|
|
*/
|
|
public function testNewMainPageNoRecursion() {
|
|
$mock = $this->createMock( MessageCache::class );
|
|
$mock->method( 'get' )->willReturn( 'localtestiw:' );
|
|
$mock->method( 'transform' )->willReturn( 'localtestiw:' );
|
|
$this->setService( 'MessageCache', $mock );
|
|
|
|
$this->assertSame(
|
|
'Main Page',
|
|
Title::newMainPage()->getPrefixedText()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::newMainPage
|
|
*/
|
|
public function testNewMainPageWithLocal() {
|
|
$local = $this->createMock( MessageLocalizer::class );
|
|
$local->method( 'msg' )->willReturn( new RawMessage( 'Prime Article' ) );
|
|
|
|
$this->assertSame(
|
|
'Prime Article',
|
|
Title::newMainPage( $local )->getText()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getTitleProtection
|
|
*/
|
|
public function testGetTitleProtection() {
|
|
$title = $this->getNonexistingTestPage( 'UTest1' )->getTitle();
|
|
$this->assertFalse( $title->getTitleProtection() );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::deleteTitleProtection
|
|
*/
|
|
public function testDeleteTitleProtection() {
|
|
$title = $this->getExistingTestPage( 'UTest1' )->getTitle();
|
|
$this->assertFalse( $title->getTitleProtection() );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getCdnUrls
|
|
*/
|
|
public function testGetCdnUrls() {
|
|
$this->assertEquals(
|
|
[
|
|
'https://example.org/wiki/Example',
|
|
'https://example.org/w/index.php?title=Example&action=history',
|
|
],
|
|
Title::makeTitle( NS_MAIN, 'Example' )->getCdnUrls(),
|
|
'article'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @covers \MediaWiki\Page\PageStore::getSubpages
|
|
*/
|
|
public function testGetSubpages() {
|
|
$existingPage = $this->getExistingTestPage();
|
|
$title = $existingPage->getTitle();
|
|
|
|
$this->overrideConfigValue(
|
|
MainConfigNames::NamespacesWithSubpages,
|
|
[ $title->getNamespace() => true ]
|
|
);
|
|
|
|
$this->getExistingTestPage( $title->getSubpage( 'A' ) );
|
|
$this->getExistingTestPage( $title->getSubpage( 'B' ) );
|
|
|
|
$notQuiteSubpageTitle = $title->getPrefixedDBkey() . 'X'; // no slash!
|
|
$this->getExistingTestPage( $notQuiteSubpageTitle );
|
|
|
|
$subpages = iterator_to_array( $title->getSubpages() );
|
|
|
|
$this->assertCount( 2, $subpages );
|
|
$this->assertCount( 1, $title->getSubpages( 1 ) );
|
|
}
|
|
|
|
/**
|
|
* @covers \MediaWiki\Page\PageStore::getSubpages
|
|
*/
|
|
public function testGetSubpages_disabled() {
|
|
$this->overrideConfigValue( MainConfigNames::NamespacesWithSubpages, [] );
|
|
|
|
$existingPage = $this->getExistingTestPage();
|
|
$title = $existingPage->getTitle();
|
|
|
|
$this->getExistingTestPage( $title->getSubpage( 'A' ) );
|
|
$this->getExistingTestPage( $title->getSubpage( 'B' ) );
|
|
|
|
$this->assertSame( [], $title->getSubpages() );
|
|
}
|
|
|
|
public static function provideNamespaces() {
|
|
// For ->isExternal() code path, construct a title with interwiki
|
|
$title = Title::makeTitle( NS_FILE, 'test', 'frag', 'meta' );
|
|
return [
|
|
[ NS_MAIN, '' ],
|
|
[ NS_FILE, 'File' ],
|
|
[ NS_MEDIA, 'Media' ],
|
|
[ NS_TALK, 'Talk' ],
|
|
[ NS_CATEGORY, 'Category' ],
|
|
[ $title, 'File' ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getNsText
|
|
* @dataProvider provideNamespaces
|
|
*/
|
|
public function testGetNsText( $namespace, $expected ) {
|
|
if ( $namespace instanceof Title ) {
|
|
$this->assertSame( $expected, $namespace->getNsText() );
|
|
} else {
|
|
$actual = Title::makeTitle( $namespace, 'Title_test' )->getNsText();
|
|
$this->assertSame( $expected, $actual );
|
|
}
|
|
}
|
|
|
|
public static function providePagesWithSubjects() {
|
|
return [
|
|
[ Title::makeTitle( NS_USER_TALK, 'User_test' ), 'User' ],
|
|
[ Title::makeTitle( NS_PROJECT, 'Test' ), 'Project' ],
|
|
[ Title::makeTitle( NS_MAIN, 'Test' ), '' ],
|
|
[ Title::makeTitle( NS_CATEGORY, 'Cat_test' ), 'Category' ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getSubjectNsText
|
|
* @dataProvider providePagesWithSubjects
|
|
*/
|
|
public function testGetSubjectNsText( Title $title, $expected ) {
|
|
$actual = $title->getSubjectNsText();
|
|
$this->assertSame( $expected, $actual );
|
|
}
|
|
|
|
public static function provideTitlesWithTalkPages() {
|
|
return [
|
|
[ Title::makeTitle( NS_HELP, 'Help page' ), 'Help_talk' ],
|
|
[ Title::newMainPage(), 'Talk' ],
|
|
[ Title::makeTitle( NS_PROJECT, 'Test' ), 'Project_talk' ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getTalkNsText
|
|
* @dataProvider provideTitlesWithTalkPages
|
|
*/
|
|
public function testGetTalkNsText( Title $title, $expected ) {
|
|
$actual = $title->getTalkNsText();
|
|
$this->assertSame( $expected, $actual );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::isSpecial
|
|
*/
|
|
public function testIsSpecial() {
|
|
$title = Title::makeTitle( NS_SPECIAL, 'Recentchanges/Subpage' );
|
|
$this->assertTrue( $title->isSpecial( 'Recentchanges' ) );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::isSpecial
|
|
*/
|
|
public function testIsNotSpecial() {
|
|
$title = Title::newFromText( 'NotSpecialPage/Subpage', NS_SPECIAL );
|
|
$this->assertFalse( $title->isSpecial( 'NotSpecialPage' ) );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::isTalkPage
|
|
*/
|
|
public function testIsTalkPage() {
|
|
$title = Title::newFromText( 'Talk page', NS_TALK );
|
|
$this->assertTrue( $title->isTalkPage() );
|
|
|
|
$titleNotInTalkNs = Title::makeTitle( NS_HELP, 'Test' );
|
|
$this->assertFalse( $titleNotInTalkNs->isTalkPage() );
|
|
}
|
|
|
|
/**
|
|
* @coversNothing
|
|
*/
|
|
public function testGetBacklinkCache() {
|
|
$blcFactory = $this->getServiceContainer()->getBacklinkCacheFactory();
|
|
$backlinkCache = $blcFactory->getBacklinkCache( Title::makeTitle( NS_FILE, 'Test' ) );
|
|
$this->assertInstanceOf( BacklinkCache::class, $backlinkCache );
|
|
}
|
|
|
|
public static function provideNsWithSubpagesSupport() {
|
|
return [
|
|
[ NS_HELP, 'Mainhelp', 'Mainhelp/Subhelp' ],
|
|
[ NS_USER, 'Mainuser', 'Mainuser/Subuser' ],
|
|
[ NS_TALK, 'Maintalk', 'Maintalk/Subtalk' ],
|
|
[ NS_PROJECT, 'Mainproject', 'Mainproject/Subproject' ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::isSubpage
|
|
* @covers MediaWiki\Title\Title::isSubpageOf
|
|
* @dataProvider provideNsWithSubpagesSupport
|
|
*/
|
|
public function testIsSubpageOfWithNamespacesSubpages( $namespace, $pageName, $subpageName ) {
|
|
$page = Title::makeTitle( $namespace, $pageName, '', 'meta' );
|
|
$subPage = Title::makeTitle( $namespace, $subpageName, '', 'meta' );
|
|
|
|
$this->assertTrue( $subPage->isSubpageOf( $page ) );
|
|
$this->assertTrue( $subPage->isSubpage() );
|
|
}
|
|
|
|
public static function provideNsWithNoSubpages() {
|
|
return [
|
|
[ NS_CATEGORY, 'Maincat', 'Maincat/Subcat' ],
|
|
[ NS_MAIN, 'Mainpage', 'Mainpage/Subpage' ]
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::isSubpage
|
|
* @covers MediaWiki\Title\Title::isSubpageOf
|
|
* @dataProvider provideNsWithNoSubpages
|
|
*/
|
|
public function testIsSubpageOfWithoutNamespacesSubpages( $namespace, $pageName, $subpageName ) {
|
|
$page = Title::makeTitle( $namespace, $pageName, '', 'meta' );
|
|
$subPage = Title::makeTitle( $namespace, $subpageName, '', 'meta' );
|
|
|
|
$this->assertFalse( $page->isSubpageOf( $page ) );
|
|
$this->assertFalse( $subPage->isSubpage() );
|
|
}
|
|
|
|
public static function provideTitleEditURLs() {
|
|
return [
|
|
[ Title::makeTitle( NS_MAIN, 'Title' ), '/w/index.php?title=Title&action=edit' ],
|
|
[ Title::makeTitle( NS_HELP, 'Test', '', 'mw' ), '' ],
|
|
[ Title::makeTitle( NS_HELP, 'Test' ), '/w/index.php?title=Help:Test&action=edit' ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getEditURL
|
|
* @dataProvider provideTitleEditURLs
|
|
*/
|
|
public function testGetEditURL( Title $title, $expected ) {
|
|
$actual = $title->getEditURL();
|
|
$this->assertSame( $expected, $actual );
|
|
}
|
|
|
|
public static function provideTitleEditURLsWithActionPaths() {
|
|
return [
|
|
[ Title::newFromText( 'Title', NS_MAIN ), '/wiki/edit/Title' ],
|
|
[ Title::makeTitle( NS_HELP, 'Test', '', 'mw' ), '' ],
|
|
[ Title::newFromText( 'Test', NS_HELP ), '/wiki/edit/Help:Test' ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getEditURL
|
|
* @dataProvider provideTitleEditURLsWithActionPaths
|
|
*/
|
|
public function testGetEditUrlWithActionPaths( Title $title, $expected ) {
|
|
$this->overrideConfigValue( MainConfigNames::ActionPaths, [ 'edit' => '/wiki/edit/$1' ] );
|
|
$actual = $title->getEditURL();
|
|
$this->assertSame( $expected, $actual );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::isMainPage
|
|
* @covers MediaWiki\Title\Title::equals
|
|
*/
|
|
public function testIsMainPage() {
|
|
$this->assertTrue( Title::newMainPage()->isMainPage() );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::isMainPage
|
|
* @covers MediaWiki\Title\Title::equals
|
|
* @dataProvider provideMainPageTitles
|
|
*/
|
|
public function testIsNotMainPage( Title $title, $expected ) {
|
|
$this->assertSame( $expected, $title->isMainPage() );
|
|
}
|
|
|
|
public static function provideMainPageTitles() {
|
|
return [
|
|
[ Title::makeTitle( NS_MAIN, 'Test' ), false ],
|
|
[ Title::makeTitle( NS_CATEGORY, 'mw:Category' ), false ],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getPrefixedURL
|
|
* @covers MediaWiki\Title\Title::prefix
|
|
* @dataProvider provideDataForTestGetPrefixedURL
|
|
*/
|
|
public function testGetPrefixedURL( Title $title, $expected ) {
|
|
$actual = $title->getPrefixedURL();
|
|
|
|
$this->assertSame( $expected, $actual );
|
|
}
|
|
|
|
public static function provideDataForTestGetPrefixedURL() {
|
|
return [
|
|
[ Title::makeTitle( NS_FILE, 'Title' ), 'File:Title' ],
|
|
[ Title::makeTitle( NS_MEDIA, 'Title' ), 'Media:Title' ],
|
|
[ Title::makeTitle( NS_CATEGORY, 'Title' ), 'Category:Title' ],
|
|
[ Title::makeTitle( NS_FILE, 'Title with spaces' ), 'File:Title_with_spaces' ],
|
|
[
|
|
Title::makeTitle( NS_FILE, 'Title with spaces', '', 'mw' ),
|
|
'mw:File:Title_with_spaces'
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::__toString
|
|
*/
|
|
public function testToString() {
|
|
$title = Title::makeTitle( NS_USER, 'User test' );
|
|
|
|
$this->assertSame( 'User:User test', (string)$title );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getFullText
|
|
* @dataProvider provideDataForTestGetFullText
|
|
*/
|
|
public function testGetFullText( Title $title, $expected ) {
|
|
$actual = $title->getFullText();
|
|
|
|
$this->assertSame( $expected, $actual );
|
|
}
|
|
|
|
public static function provideDataForTestGetFullText() {
|
|
return [
|
|
[ Title::makeTitle( NS_TALK, 'Test' ), 'Talk:Test' ],
|
|
[ Title::makeTitle( NS_HELP, 'Test', 'frag' ), 'Help:Test#frag' ],
|
|
[ Title::makeTitle( NS_TALK, 'Test', 'frag', 'phab' ), 'phab:Talk:Test#frag' ],
|
|
];
|
|
}
|
|
|
|
public static function provideIsSamePageAs() {
|
|
$title = Title::makeTitle( 0, 'Foo' );
|
|
$title->resetArticleID( 1 );
|
|
yield '(PageIdentityValue) same text, title has ID 0' => [
|
|
$title,
|
|
new PageIdentityValue( 1, 0, 'Foo', PageIdentity::LOCAL ),
|
|
true
|
|
];
|
|
|
|
$title = Title::makeTitle( 1, 'Bar_Baz' );
|
|
$title->resetArticleID( 0 );
|
|
yield '(PageIdentityValue) same text, PageIdentityValue has ID 0' => [
|
|
$title,
|
|
new PageIdentityValue( 0, 1, 'Bar_Baz', PageIdentity::LOCAL ),
|
|
true
|
|
];
|
|
|
|
$title = Title::makeTitle( 0, 'Foo' );
|
|
$title->resetArticleID( 0 );
|
|
yield '(PageIdentityValue) different text, both IDs are 0' => [
|
|
$title,
|
|
new PageIdentityValue( 0, 0, 'Foozz', PageIdentity::LOCAL ),
|
|
false
|
|
];
|
|
|
|
$title = Title::makeTitle( 0, 'Foo' );
|
|
$title->resetArticleID( 0 );
|
|
yield '(PageIdentityValue) different namespace' => [
|
|
$title,
|
|
new PageIdentityValue( 0, 1, 'Foo', PageIdentity::LOCAL ),
|
|
false
|
|
];
|
|
|
|
$title = Title::makeTitle( 0, 'Foo', '' );
|
|
$title->resetArticleID( 1 );
|
|
yield '(PageIdentityValue) different wiki, different ID' => [
|
|
$title,
|
|
new PageIdentityValue( 1, 0, 'Foo', 'bar' ),
|
|
false
|
|
];
|
|
|
|
$title = Title::makeTitle( 0, 'Foo', '' );
|
|
$title->resetArticleID( 0 );
|
|
yield '(PageIdentityValue) different wiki, both IDs are 0' => [
|
|
$title,
|
|
new PageIdentityValue( 0, 0, 'Foo', 'bar' ),
|
|
false
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::isSamePageAs
|
|
* @dataProvider provideIsSamePageAs
|
|
*/
|
|
public function testIsSamePageAs( Title $firstValue, $secondValue, $expectedSame ) {
|
|
$this->assertSame(
|
|
$expectedSame,
|
|
$firstValue->isSamePageAs( $secondValue )
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getArticleID
|
|
* @covers MediaWiki\Title\Title::getId
|
|
* @covers MediaWiki\Title\Title::getLength
|
|
* @covers MediaWiki\Title\Title::getLatestRevID
|
|
* @covers MediaWiki\Title\Title::exists
|
|
* @covers MediaWiki\Title\Title::isNewPage
|
|
* @covers MediaWiki\Title\Title::isRedirect
|
|
* @covers MediaWiki\Title\Title::getTouched
|
|
* @covers MediaWiki\Title\Title::getContentModel
|
|
* @covers MediaWiki\Title\Title::getFieldFromPageStore
|
|
*/
|
|
public function testGetFieldsOfNonExistingPage() {
|
|
$title = Title::makeTitle( NS_MAIN, 'ThisDoesNotExist-92347852349' );
|
|
|
|
$this->assertSame( 0, $title->getArticleID() );
|
|
$this->assertSame( 0, $title->getId() );
|
|
$this->assertSame( 0, $title->getLength() );
|
|
$this->assertSame( 0, $title->getLatestRevID() );
|
|
$this->assertFalse( $title->exists() );
|
|
$this->assertFalse( $title->isNewPage() );
|
|
$this->assertFalse( $title->isRedirect() );
|
|
$this->assertFalse( $title->getTouched() );
|
|
$this->assertNotEmpty( $title->getContentModel() );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getDefaultSystemMessage
|
|
*/
|
|
public function testGetDefaultSystemMessage() {
|
|
$title = Title::makeTitle( NS_MEDIAWIKI, 'Logouttext' );
|
|
|
|
$this->assertInstanceOf( Message::class, $title->getDefaultSystemMessage() );
|
|
$this->assertStringContainsString( 'You are now logged out', $title->getDefaultMessageText() );
|
|
}
|
|
|
|
/**
|
|
* @covers MediaWiki\Title\Title::getDefaultSystemMessage
|
|
*/
|
|
public function testGetDefaultSystemMessageReturnsNull() {
|
|
$title = Title::makeTitle( NS_MAIN, 'Some title' );
|
|
|
|
$this->assertNull( $title->getDefaultSystemMessage() );
|
|
}
|
|
|
|
}
|