tags,
// which may not be desired in some cases
$newline = isset( $param['compact'] ) ? '' : "\n";
$tag = $parser->insertStripItem( "
" );
// replace colons with indented spans
$text = preg_replace_callback(
'/^(:++)(.+)$/m',
static function ( array $matches ) {
$indentation = strlen( $matches[1] ) . 'em';
return Html::rawElement(
'span',
[
'class' => 'mw-poem-indented',
'style' => 'display: inline-block; ' .
"margin-inline-start: $indentation;",
],
$matches[2]
);
},
$in ?? ''
);
// replace newlines with
tags unless they are at the beginning or end
// of the poem, or would directly follow exactly 4 dashes. See Parser::internalParse() for
// the exact syntax for horizontal rules.
$text = preg_replace(
[ '/^\n/', '/\n$/D', '/(?recursiveTagParse( $text, $frame );
// Because of limitations of the regular expression above, horizontal rules with more than 4
// dashes still need special handling.
$text = str_replace( '
Text.
", "Text.", ], [ "Text.
", "Text.
", ], [ "Text.\n
\n", "Text.", ], [ "Text.
More text.
", "Text.
More text.
", ], [ $message->parse(), "Message text.", ], ]; } /** * @dataProvider provideStripOuterParagraph */ public function testStripOuterParagraph( $text, $expected ) { $this->assertEquals( $expected, Parser::stripOuterParagraph( $text ) ); } public static function provideFormatPageTitle() { return [ "Non-main namespace" => [ [ 'Talk', ':', 'Hello' ], 'Talk:Hello', ], "Main namespace (ignores the separator)" => [ [ '', ':', 'Hello' ], 'Hello', ], "Pieces are HTML-escaped" => [ [ 'Ta&lk', ':', 'He&llo' ], 'Ta&lk:He&llo', ], "In the future, the colon separator could be localized" => [ [ 'Talk', ' : ', 'Hello' ], 'Talk : Hello', ], "In the future, displaytitle could be customized separately from the namespace" => [ [ 'Talk', ':', new HtmlArmor( 'Hello' ) ], 'Talk:Hello', ], ]; } /** * @dataProvider provideFormatPageTitle */ public function testFormatPageTitle( $args, $expected ) { $this->assertEquals( $expected, Parser::formatPageTitle( ...$args ) ); } public function testRecursiveParse() { $title = Title::makeTitle( NS_MAIN, 'Foo' ); $parser = $this->getServiceContainer()->getParser(); $po = ParserOptions::newFromAnon(); $parser->setHook( 'recursivecallparser', [ $this, 'helperParserFunc' ] ); $this->expectException( LogicException::class ); $this->expectExceptionMessage( "Parser state cleared while parsing. Did you call Parser::parse recursively?" ); $parser->parse( 'foo', ], $ret, 'callParserFunction works for {{#tag:pre|foo|style=margin-left: 1.6em}}' ); } /** * @covers \MediaWiki\Parser\Parser * @covers \MediaWiki\Parser\ParserOutput::getSections */ public function testGetSections() { $this->overrideConfigValue( MainConfigNames::FragmentMode, [ 'html5' ] ); $title = Title::makeTitle( NS_MAIN, 'TestGetSections' ); $out = $this->getServiceContainer()->getParser()->parse( "==foo==\n
One
Two
Two point one
Three
EOF; $dedupText = <<One
Two
Two point one
Three
EOF ], 'Disable section edit links' => [ [ 'enableSectionEditLinks' => false ], $text, <<One
Two
Two point one
Three
EOF ], 'Disable TOC, but wrap' => [ [ 'allowTOC' => false, 'wrapperDivClass' => 'mw-parser-output' ], $text, <<Test document.
One
Two
Two point one
Three
monospaced', '
monospaced', '
in preloaded text must be unstripped (T29467)'
);
}
public function testPreloadedNowikiIsUnstripped() {
$this->assertPreloaded(
'[[Dummy title]] ',
'[[Dummy title]] ',
' in preloaded text must be unstripped (T29467)'
);
}
protected function assertPreloaded( $expected, $text, $msg = '' ) {
$this->assertEquals(
$expected,
$this->testParser->getPreloadText(
$text,
$this->title,
$this->testParserOptions
),
$msg
);
}
}
PK ! &Q* * parser/MagicVariableTest.phpnu Iw getServiceContainer();
$contLang = $services->getLanguageFactory()->getLanguage( 'en' );
$this->setService( 'ContentLanguage', $contLang );
$this->overrideConfigValues( [
MainConfigNames::LanguageCode => $contLang->getCode(),
// NOTE: Europe/Stockholm DST applies Sun, Mar 26, 2023 2:00 - Sun, Oct 29, 2023 3:00AM
MainConfigNames::Localtimezone => 'Europe/Stockholm',
MainConfigNames::MiserMode => false,
MainConfigNames::ParserCacheExpireTime => 86400 * 7,
] );
$this->testParser = $services->getParserFactory()->create();
$this->testParser->setOptions( ParserOptions::newFromUserAndLang( new User, $contLang ) );
# initialize parser output
$this->testParser->clearState();
# Needs a title to do magic word stuff
$title = Title::makeTitle( NS_MAIN, 'Tests' );
# Else it needs a db connection just to check if it's a redirect
# (when deciding the page language).
$title->mRedirect = false;
$this->testParser->setTitle( $title );
}
/**
* @param int $num Upper limit for numbers
* @return array Array of strings naming numbers from 1 up to $num
*/
private static function createProviderUpTo( $num ) {
$ret = [];
for ( $i = 1; $i <= $num; $i++ ) {
$ret[] = [ strval( $i ) ];
}
return $ret;
}
/**
* @return array Array of months numbers (as an integer)
*/
public static function provideMonths() {
return self::createProviderUpTo( 12 );
}
/**
* @return array Array of days numbers (as an integer)
*/
public static function provideDays() {
return self::createProviderUpTo( 31 );
}
# ############## TESTS #############################################
# @todo FIXME:
# - those got copy pasted, we can probably make them cleaner
# - tests are lacking useful messages
# day
/** @dataProvider provideDays */
public function testCurrentdayIsUnPadded( $day ) {
$this->assertUnPadded( 'currentday', $day );
}
/** @dataProvider provideDays */
public function testCurrentdaytwoIsZeroPadded( $day ) {
$this->assertZeroPadded( 'currentday2', $day );
}
/** @dataProvider provideDays */
public function testLocaldayIsUnPadded( $day ) {
$this->assertUnPadded( 'localday', $day );
}
/** @dataProvider provideDays */
public function testLocaldaytwoIsZeroPadded( $day ) {
$this->assertZeroPadded( 'localday2', $day );
}
# month
/** @dataProvider provideMonths */
public function testCurrentmonthIsZeroPadded( $month ) {
$this->assertZeroPadded( 'currentmonth', $month );
}
/** @dataProvider provideMonths */
public function testCurrentmonthoneIsUnPadded( $month ) {
$this->assertUnPadded( 'currentmonth1', $month );
}
/** @dataProvider provideMonths */
public function testLocalmonthIsZeroPadded( $month ) {
$this->assertZeroPadded( 'localmonth', $month );
}
/** @dataProvider provideMonths */
public function testLocalmonthoneIsUnPadded( $month ) {
$this->assertUnPadded( 'localmonth1', $month );
}
# revision day
/** @dataProvider provideDays */
public function testRevisiondayIsUnPadded( $day ) {
$this->assertUnPadded( 'revisionday', $day );
}
/** @dataProvider provideDays */
public function testRevisiondaytwoIsZeroPadded( $day ) {
$this->assertZeroPadded( 'revisionday2', $day );
}
# revision month
/** @dataProvider provideMonths */
public function testRevisionmonthIsZeroPadded( $month ) {
$this->assertZeroPadded( 'revisionmonth', $month );
}
/** @dataProvider provideMonths */
public function testRevisionmonthoneIsUnPadded( $month ) {
$this->assertUnPadded( 'revisionmonth1', $month );
}
public static function provideCurrentUnitTimestampWords() {
return [
// Afternoon
[ 'currentmonth', '20200208153011', '02', 604800 ],
[ 'currentmonth1', '20200208153011', '2', 604800 ],
[ 'currentmonthname', '20200208153011', 'February', 604800 ],
[ 'currentmonthnamegen', '20200208153011', 'February', 604800 ],
[ 'currentmonthabbrev', '20200208153011', 'Feb', 604800 ],
[ 'currentday', '20200208153011', '8', 30601 ],
[ 'currentday2', '20200208153011', '08', 30601 ],
[ 'currentdayname', '20200208153011', 'Saturday', 30601 ],
[ 'currentyear', '20200208153011', '2020', 604800 ],
[ 'currenthour', '20200208153011', '15', 1801 ],
[ 'currentweek', '20200208153011', '6', 30601 ],
[ 'currentdow', '20200208153011', '6', 30601 ],
[ 'currenttime', '20200208153011', '15:30', 3600 ],
// Night
[ 'currentmonth', '20200208223011', '02', 604800 ],
[ 'currentmonth1', '20200208223011', '2', 604800 ],
[ 'currentmonthname', '20200208223011', 'February', 604800 ],
[ 'currentmonthnamegen', '20200208223011', 'February', 604800 ],
[ 'currentmonthabbrev', '20200208223011', 'Feb', 604800 ],
[ 'currentday', '20200208223011', '8', 5401 ],
[ 'currentday2', '20200208223011', '08', 5401 ],
[ 'currentdayname', '20200208223011', 'Saturday', 5401 ],
[ 'currentyear', '20200208223011', '2020', 604800 ],
[ 'currenthour', '20200208223011', '22', 1801 ],
[ 'currentweek', '20200208223011', '6', 5401 ],
[ 'currentdow', '20200208223011', '6', 5401 ],
[ 'currenttime', '20200208223011', '22:30', 3600 ]
];
}
public static function provideLocalUnitTimestampWords() {
// NOTE: Europe/Stockholm DST applies Sun, Mar 26, 2023 2:00 - Sun, Oct 29, 2023 3:00AM
return [
// Afternoon
[ 'localmonth', '20200208153011', '02', 604800 ],
[ 'localmonth1', '20200208153011', '2', 604800 ],
[ 'localmonthname', '20200208153011', 'February', 604800 ],
[ 'localmonthnamegen', '20200208153011', 'February', 604800 ],
[ 'localmonthabbrev', '20200208153011', 'Feb', 604800 ],
[ 'localday', '20200208153011', '8', 27001 ],
[ 'localday2', '20200208153011', '08', 27001 ],
[ 'localdayname', '20200208153011', 'Saturday', 27001 ],
[ 'localyear', '20200208153011', '2020', 604800 ],
[ 'localhour', '20200208153011', '16', 1801 ],
[ 'localweek', '20200208153011', '6', 27001 ],
[ 'localdow', '20200208153011', '6', 27001 ],
[ 'localtime', '20200208153011', '16:30', 3600 ],
// Night
[ 'localmonth', '20200208223011', '02', 604800 ],
[ 'localmonth1', '20200208223011', '2', 604800 ],
[ 'localmonthname', '20200208223011', 'February', 604800 ],
[ 'localmonthnamegen', '20200208223011', 'February', 604800 ],
[ 'localmonthabbrev', '20200208223011', 'Feb', 604800 ],
[ 'localday', '20200208223011', '8', 1801 ],
[ 'localday2', '20200208223011', '08', 1801 ],
[ 'localdayname', '20200208223011', 'Saturday', 1801 ],
[ 'localyear', '20200208223011', '2020', 604800 ],
[ 'localhour', '20200208223011', '23', 1801 ],
[ 'localweek', '20200208223011', '6', 1801 ],
[ 'localdow', '20200208223011', '6', 1801 ],
[ 'localtime', '20200208223011', '23:30', 3600 ],
// Late night / early morning
[ 'localmonth', '20200208233011', '02', 604800 ],
[ 'localmonth1', '20200208233011', '2', 604800 ],
[ 'localmonthname', '20200208233011', 'February', 604800 ],
[ 'localmonthnamegen', '20200208233011', 'February', 604800 ],
[ 'localmonthabbrev', '20200208233011', 'Feb', 604800 ],
[ 'localday', '20200208233011', '9', 84601 ],
[ 'localday2', '20200208233011', '09', 84601 ],
[ 'localdayname', '20200208233011', 'Sunday', 84601 ],
[ 'localyear', '20200208233011', '2020', 604800 ],
[ 'localhour', '20200208233011', '00', 1801 ],
[ 'localweek', '20200208233011', '6', 84601 ],
[ 'localdow', '20200208233011', '0', 84601 ],
[ 'localtime', '20200208233011', '00:30', 3600 ]
];
}
/**
* @param string $word
* @param string $ts
* @param string $expOutput
* @param int $expTTL
* @dataProvider provideCurrentUnitTimestampWords
* @dataProvider provideLocalUnitTimestampWords
*/
public function testCurrentUnitTimestampExpiry( $word, $ts, $expOutput, $expTTL ) {
$this->setParserTimestamp( $ts );
$this->assertMagic( $expOutput, $word );
$this->assertSame( $expTTL, $this->testParser->getOutput()->getCacheExpiry() );
}
# ############## HELPERS ############################################
/**
* assertion helper expecting a magic output which is zero padded
* @param string $magic
* @param string $value
*/
public function assertZeroPadded( $magic, $value ) {
$this->assertMagicPadding( $magic, $value, '%02d' );
}
/**
* assertion helper expecting a magic output which is unpadded
* @param string $magic
* @param string $value
*/
public function assertUnPadded( $magic, $value ) {
$this->assertMagicPadding( $magic, $value, '%d' );
}
/**
* Main assertion helper for magic variables padding
* @param string $magic Magic variable name
* @param mixed $value Month or day
* @param string $format Sprintf format for $value
*/
private function assertMagicPadding( $magic, $value, $format ) {
# Initialize parser timestamp as year 2010 at 12h34 56s.
# month and day are given by the caller ($value). Month < 12!
if ( $value > 12 ) {
$month = $value % 12;
} else {
$month = $value;
}
$this->setParserTimestamp(
sprintf( '2010%02d%02d123456', $month, $value )
);
# please keep the following commented line of code. It helps debugging.
// print "\nDEBUG (value $value):" . sprintf( '2010%02d%02d123456', $value, $value ) . "\n";
# format expectation and test it
$expected = sprintf( $format, $value );
$this->assertMagic( $expected, $magic );
}
/**
* helper to set the parser timestamp and revision timestamp
* @param string $ts
*/
private function setParserTimestamp( $ts ) {
$this->testParser->getOptions()->setTimestamp( $ts );
TestingAccessWrapper::newFromObject( $this->testParser )->mRevisionTimestamp = $ts;
}
/**
* Assertion helper to test a magic variable output
* @param string|int $expected
* @param string $magic
*/
private function assertMagic( $expected, $magic ) {
# Generate a message for the assertion
$msg = sprintf( "Magic %s should be <%s:%s>",
$magic,
$expected,
get_debug_type( $expected )
);
$this->assertSame(
$expected,
TestingAccessWrapper::newFromObject( $this->testParser )->expandMagicVariable( $magic ),
$msg
);
}
}
PK ! PY Y " parser/PageBundleJsonTraitTest.phpnu Iw 'woohoo
',
'parsoid' => [ 'metadata' => 'foo' ],
'mw' => null,
'version' => '1.0',
'headers' => [ 'bar' => 'baz' ],
'contentmodel' => 'default'
];
public function testNewPageBundleFromJson() {
$trait = new class {
use PageBundleJsonTrait {
newPageBundleFromJson as public;
}
};
$bundle = $trait->newPageBundleFromJson( self::BUNDLE_DATA );
$this->assertInstanceOf( PageBundle::class, $bundle );
$this->assertEquals( 'woohoo
', $bundle->html );
$this->assertEquals( 'default', $bundle->contentmodel );
$this->assertNull( $bundle->mw );
}
public function testJsonSerializePageBundle() {
$trait = new class {
use PageBundleJsonTrait {
jsonSerializePageBundle as public;
}
};
$bundle = new PageBundle( ...array_values( self::BUNDLE_DATA ) );
$json = $trait->jsonSerializePageBundle( $bundle );
$this->assertEquals( PageBundle::class, $json['_type_'] );
$this->assertEquals( 'woohoo
', $json['html'] );
$this->assertNull( $json['mw'] );
}
}
PK ! ,OZ ' parser/Parsoid/LintErrorCheckerTest.phpnu Iw overrideConfigValue( MainConfigNames::ParsoidSettings, [
'linting' => true
] );
$this->overrideConfigValue( 'LinterCategories', [
// No hidden categories in default set up
] );
}
/**
* Get a basic LintErrorChecker for testing with.
* @return LintErrorChecker
*/
protected function getLintErrorChecker() {
$services = $this->getServiceContainer();
$extReg = $this->createMock( ExtensionRegistry::class );
$extReg->method( 'isLoaded' )->willReturnCallback( static function ( string $which ) {
return $which == 'Linter';
} );
return new LintErrorChecker(
$services->get( '_Parsoid' ),
$services->getParsoidPageConfigFactory(),
$services->getTitleFactory(),
$extReg,
$services->getMainConfig(),
);
}
/**
* @dataProvider provideCheck
*/
public function testCheck( $wikitext, $expected ) {
$errors = $this->getLintErrorChecker()->check( $wikitext );
$this->assertSame( $expected, $errors );
}
public static function provideCheck() {
yield 'Perfect' => [ 'Foo', [] ];
yield 'Unclosed tag' => [
'Foo',
[
[
'type' => 'missing-end-tag',
'dsr' => [ 0, 11, 8, 0 ],
'templateInfo' => null,
'params' => [
'name' => 'strong',
'inTable' => false,
]
]
]
];
}
public function testCheckSome() {
// Take the same "Unclosed tag" test from above but disable the category
$errors = $this->getLintErrorChecker()->checkSome( 'Foo', [ 'missing-end-tag' ] );
$this->assertSame( [], $errors );
}
/** Test when categories are diabled in $wgLinterCategories */
public function testLinterCategory() {
$input = 'RED';
$errors = $this->getLintErrorChecker()->check( $input );
$this->assertEquals( 'obsolete-tag', $errors[0]['type'] );
// Now disable the category
$this->overrideConfigValue( 'LinterCategories', [
'obsolete-tag' => [ 'priority' => 'none' ],
] );
$errors = $this->getLintErrorChecker()->check( $input );
$this->assertSame( [], $errors );
}
}
PK ! @!T " parser/CoreParserFunctionsTest.phpnu Iw getServiceContainer()->getUserOptionsManager();
$username = 'Female*';
$user = User::createNew( $username );
$userOptionsManager->setOption( $user, 'gender', 'female' );
$user->saveSettings();
$msg = ( new RawMessage( '{{GENDER:' . $username . '|m|f|o}}' ) )->parse();
$this->assertEquals( 'f', $msg, 'Works unescaped' );
$escapedName = wfEscapeWikiText( $username );
$msg2 = ( new RawMessage( '{{GENDER:' . $escapedName . '|m|f|o}}' ) )
->parse();
$this->assertEquals( 'f', $msg2, 'Works escaped' );
}
public static function provideTalkpagename() {
yield [ 'Talk:Foo bar', 'foo_bar' ];
yield [ 'Talk:Foo', ' foo ' ];
yield [ 'Talk:Foo', 'Talk:Foo' ];
yield [ 'User talk:Foo', 'User:foo' ];
yield [ '', 'Special:Foo' ];
yield [ '', '' ];
yield [ '', ' ' ];
yield [ '', '__' ];
yield [ '', '#xyzzy' ];
yield [ '', '#' ];
yield [ '', ':' ];
yield [ '', ':#' ];
yield [ '', 'User:' ];
yield [ '', 'User:#' ];
}
/**
* @dataProvider provideTalkpagename
*/
public function testTalkpagename( $expected, $title ) {
$parser = $this->getServiceContainer()->getParser();
$this->assertSame( $expected, CoreParserFunctions::talkpagename( $parser, $title ) );
}
public static function provideSubjectpagename() {
yield [ 'Foo bar', 'Talk:foo_bar' ];
yield [ 'Foo', ' Talk:foo ' ];
yield [ 'User:Foo', 'User talk:foo' ];
yield [ 'Special:Foo', 'Special:Foo' ];
yield [ '', '' ];
yield [ '', ' ' ];
yield [ '', '__' ];
yield [ '', '#xyzzy' ];
yield [ '', '#' ];
yield [ '', ':' ];
yield [ '', ':#' ];
yield [ '', 'Talk:' ];
yield [ '', 'User talk:#' ];
yield [ '', 'User:#' ];
}
/**
* @dataProvider provideSubjectpagename
*/
public function testSubjectpagename( $expected, $title ) {
$parser = $this->getServiceContainer()->getParser();
$this->assertSame( $expected, CoreParserFunctions::subjectpagename( $parser, $title ) );
}
}
PK ! X # GlobalFunctions/WfExpandUrlTest.phpnu Iw $options[UrlUtils::SERVER] ?? null,
MainConfigNames::CanonicalServer => $options[UrlUtils::CANONICAL_SERVER] ?? null,
MainConfigNames::InternalServer => $options[UrlUtils::INTERNAL_SERVER] ?? null,
MainConfigNames::HttpsPort => $options[UrlUtils::HTTPS_PORT] ?? 443,
];
$currentProto = $options[UrlUtils::FALLBACK_PROTOCOL];
$this->overrideConfigValues( $conf );
$this->setRequest( new FauxRequest( [], false, null, $currentProto ) );
$this->assertEquals( $expected, wfExpandUrl( $input, $defaultProto ) );
}
}
PK ! g0 0 GlobalFunctions/GlobalTest.phpnu Iw overrideConfigValues( [
MainConfigNames::UrlProtocols => [
'http://',
'https://',
'mailto:',
'//',
'file://', # Non-default
],
] );
}
/**
* @dataProvider provideForWfArrayDiff2
* @covers ::wfArrayDiff2
*/
public function testWfArrayDiff2( $a, $b, $expected ) {
$this->expectDeprecationAndContinue( '/wfArrayDiff2/' );
$this->assertEquals(
$expected, wfArrayDiff2( $a, $b )
);
}
// @todo Provide more tests
public static function provideForWfArrayDiff2() {
// $a $b $expected
return [
[
[ 'a', 'b' ],
[ 'a', 'b' ],
[],
],
[
[ [ 'a' ], [ 'a', 'b', 'c' ] ],
[ [ 'a' ], [ 'a', 'b' ] ],
[ 1 => [ 'a', 'b', 'c' ] ],
],
];
}
/*
* Test cases for random functions could hypothetically fail,
* even though they shouldn't.
*/
/**
* @covers ::wfRandom
*/
public function testRandom() {
$this->assertFalse(
wfRandom() == wfRandom()
);
}
/**
* @covers ::wfRandomString
*/
public function testRandomString() {
$this->assertFalse(
wfRandomString() == wfRandomString()
);
$this->assertSame( 10, strlen( wfRandomString( 10 ) ), 'length' );
$this->assertSame( 1, preg_match( '/^[0-9a-f]+$/i', wfRandomString() ), 'pattern' );
}
/**
* @covers ::wfUrlencode
*/
public function testUrlencode() {
$this->assertEquals(
"%E7%89%B9%E5%88%A5:Contributions/Foobar",
wfUrlencode( "\xE7\x89\xB9\xE5\x88\xA5:Contributions/Foobar" ) );
}
public static function provideArrayToCGI() {
return [
[ [], '' ], // empty
[ [ 'foo' => 'bar' ], 'foo=bar' ], // string test
[ [ 'foo' => '' ], 'foo=' ], // empty string test
[ [ 'foo' => 1 ], 'foo=1' ], // number test
[ [ 'foo' => true ], 'foo=1' ], // true test
[ [ 'foo' => false ], '' ], // false test
[ [ 'foo' => null ], '' ], // null test
[ [ 'foo' => 'A&B=5+6@!"\'' ], 'foo=A%26B%3D5%2B6%40%21%22%27' ], // urlencoding test
[
[ 'foo' => 'bar', 'baz' => 'is', 'asdf' => 'qwerty' ],
'foo=bar&baz=is&asdf=qwerty'
], // multi-item test
[ [ 'foo' => [ 'bar' => 'baz' ] ], 'foo%5Bbar%5D=baz' ],
[
[ 'foo' => [ 'bar' => 'baz', 'qwerty' => 'asdf' ] ],
'foo%5Bbar%5D=baz&foo%5Bqwerty%5D=asdf'
],
[ [ 'foo' => [ 'bar', 'baz' ] ], 'foo%5B0%5D=bar&foo%5B1%5D=baz' ],
[
[ 'foo' => [ 'bar' => [ 'bar' => 'baz' ] ] ],
'foo%5Bbar%5D%5Bbar%5D=baz'
],
];
}
/**
* @dataProvider provideArrayToCGI
* @covers ::wfArrayToCgi
*/
public function testArrayToCGI( $array, $result ) {
$this->assertEquals( $result, wfArrayToCgi( $array ) );
}
/**
* @covers ::wfArrayToCgi
*/
public function testArrayToCGI2() {
$this->assertEquals(
"baz=bar&foo=bar",
wfArrayToCgi(
[ 'baz' => 'bar' ],
[ 'foo' => 'bar', 'baz' => 'overridden value' ] ) );
}
public static function provideCgiToArray() {
return [
[ '', [] ], // empty
[ 'foo=bar', [ 'foo' => 'bar' ] ], // string
[ 'foo=', [ 'foo' => '' ] ], // empty string
[ 'foo', [ 'foo' => '' ] ], // missing =
[ 'foo=bar&qwerty=asdf', [ 'foo' => 'bar', 'qwerty' => 'asdf' ] ], // multiple value
[ 'foo=A%26B%3D5%2B6%40%21%22%27', [ 'foo' => 'A&B=5+6@!"\'' ] ], // urldecoding test
[ 'foo[bar]=baz', [ 'foo' => [ 'bar' => 'baz' ] ] ],
[ 'foo%5Bbar%5D=baz', [ 'foo' => [ 'bar' => 'baz' ] ] ], // urldecoding test 2
[
'foo%5Bbar%5D=baz&foo%5Bqwerty%5D=asdf',
[ 'foo' => [ 'bar' => 'baz', 'qwerty' => 'asdf' ] ]
],
[ 'foo%5B0%5D=bar&foo%5B1%5D=baz', [ 'foo' => [ 0 => 'bar', 1 => 'baz' ] ] ],
[
'foo%5Bbar%5D%5Bbar%5D=baz',
[ 'foo' => [ 'bar' => [ 'bar' => 'baz' ] ] ]
],
[ 'foo[]=x&foo[]=y', [ 'foo' => [ '' => 'y' ] ] ], // implicit keys are NOT handled like in PHP (bug?)
[ 'foo=x&foo[]=y', [ 'foo' => [ '' => 'y' ] ] ], // mixed value/array doesn't cause errors
];
}
/**
* @dataProvider provideCgiToArray
* @covers ::wfCgiToArray
*/
public function testCgiToArray( $cgi, $result ) {
$this->assertEquals( $result, wfCgiToArray( $cgi ) );
}
public static function provideCgiRoundTrip() {
return [
[ '' ],
[ 'foo=bar' ],
[ 'foo=' ],
[ 'foo=bar&baz=biz' ],
[ 'foo=A%26B%3D5%2B6%40%21%22%27' ],
[ 'foo%5Bbar%5D=baz' ],
[ 'foo%5B0%5D=bar&foo%5B1%5D=baz' ],
[ 'foo%5Bbar%5D%5Bbar%5D=baz' ],
];
}
/**
* @dataProvider provideCgiRoundTrip
* @covers ::wfArrayToCgi
*/
public function testCgiRoundTrip( $cgi ) {
$this->assertEquals( $cgi, wfArrayToCgi( wfCgiToArray( $cgi ) ) );
}
/**
* @covers ::wfDebug
*/
public function testDebugFunctionTest() {
$debugLogFile = $this->getNewTempFile();
$this->overrideConfigValue( MainConfigNames::DebugLogFile, $debugLogFile );
$this->setLogger( 'wfDebug', new LegacyLogger( 'wfDebug' ) );
unlink( $debugLogFile );
wfDebug( "This is a normal string" );
$this->assertEquals( "This is a normal string\n", file_get_contents( $debugLogFile ) );
unlink( $debugLogFile );
wfDebug( "This is nöt an ASCII string" );
$this->assertEquals( "This is nöt an ASCII string\n", file_get_contents( $debugLogFile ) );
unlink( $debugLogFile );
wfDebug( "\00305This has böth UTF and control chars\003" );
$this->assertEquals(
" 05This has böth UTF and control chars \n",
file_get_contents( $debugLogFile )
);
unlink( $debugLogFile );
}
/**
* @covers ::wfClientAcceptsGzip
*/
public function testClientAcceptsGzipTest() {
$settings = [
'gzip' => true,
'bzip' => false,
'*' => false,
'compress, gzip' => true,
'gzip;q=1.0' => true,
'foozip' => false,
'foo*zip' => false,
'gzip;q=abcde' => true, // is this REALLY valid?
'gzip;q=12345678.9' => true,
' gzip' => true,
];
if ( isset( $_SERVER['HTTP_ACCEPT_ENCODING'] ) ) {
$old_server_setting = $_SERVER['HTTP_ACCEPT_ENCODING'];
}
foreach ( $settings as $encoding => $expect ) {
$_SERVER['HTTP_ACCEPT_ENCODING'] = $encoding;
$this->assertEquals( $expect, wfClientAcceptsGzip( true ),
"'$encoding' => " . wfBoolToStr( $expect ) );
}
if ( isset( $old_server_setting ) ) {
$_SERVER['HTTP_ACCEPT_ENCODING'] = $old_server_setting;
}
}
/**
* @covers ::wfPercent
* @dataProvider provideWfPercentTest
*/
public function testWfPercentTest( float $input,
string $expected,
int $accuracy = 2,
bool $round = true
) {
$this->assertSame( $expected, wfPercent( $input, $accuracy, $round ) );
}
public static function provideWfPercentTest() {
return [
[ 6 / 7, '0.86%', 2, false ],
[ 3 / 3, '1%' ],
[ 22 / 7, '3.14286%', 5 ],
[ 3 / 6, '0.5%' ],
[ 1 / 3, '0%', 0 ],
[ 10 / 3, '0%', -1 ],
[ 123.456, '120%', -1 ],
[ 3 / 4 / 5, '0.1%', 1 ],
[ 6 / 7 * 8, '6.8571428571%', 10 ],
];
}
/**
* test @see wfShorthandToInteger()
* @dataProvider provideShorthand
* @covers ::wfShorthandToInteger
*/
public function testWfShorthandToInteger( $shorthand, $expected ) {
$this->assertEquals( $expected,
wfShorthandToInteger( $shorthand )
);
}
public static function provideShorthand() {
// Syntax: [ shorthand, expected integer ]
return [
# Null, empty ...
[ '', -1 ],
[ ' ', -1 ],
[ null, -1 ],
# Failures returns 0 :(
[ 'ABCDEFG', 0 ],
[ 'Ak', 0 ],
# Int, strings with spaces
[ 1, 1 ],
[ ' 1 ', 1 ],
[ 1023, 1023 ],
[ ' 1023 ', 1023 ],
# kilo, Mega, Giga
[ '1k', 1024 ],
[ '1K', 1024 ],
[ '1m', 1024 * 1024 ],
[ '1M', 1024 * 1024 ],
[ '1g', 1024 * 1024 * 1024 ],
[ '1G', 1024 * 1024 * 1024 ],
# Negatives
[ -1, -1 ],
[ -500, -500 ],
[ '-500', -500 ],
[ '-1k', -1024 ],
# Zeroes
[ '0', 0 ],
[ '0k', 0 ],
[ '0M', 0 ],
[ '0G', 0 ],
[ '-0', 0 ],
[ '-0k', 0 ],
[ '-0M', 0 ],
[ '-0G', 0 ],
];
}
/**
* @covers ::wfMerge
*/
public function testMerge_worksWithLessParameters() {
$this->markTestSkippedIfNoDiff3();
$mergedText = null;
$successfulMerge = wfMerge( "old1\n\nold2", "old1\n\nnew2", "new1\n\nold2", $mergedText );
$mergedText = null;
$conflictingMerge = wfMerge( 'old', 'old and mine', 'old and yours', $mergedText );
$this->assertTrue( $successfulMerge );
$this->assertFalse( $conflictingMerge );
}
/**
* @param string $old Text as it was in the database
* @param string $mine Text submitted while user was editing
* @param string $yours Text submitted by the user
* @param bool $expectedMergeResult Whether the merge should be a success
* @param string $expectedText Text after merge has been completed
* @param string $expectedMergeAttemptResult Diff3 output if conflicts occur
*
* @dataProvider provideMerge()
* @group medium
* @covers ::wfMerge
*/
public function testMerge(
$old, $mine, $yours, $expectedMergeResult, $expectedText, $expectedMergeAttemptResult
) {
$this->markTestSkippedIfNoDiff3();
$mergedText = null;
$mergeAttemptResult = null;
$isMerged = wfMerge( $old, $mine, $yours, $mergedText, $mergeAttemptResult );
$msg = 'Merge should be a ';
$msg .= $expectedMergeResult ? 'success' : 'failure';
$this->assertEquals( $expectedMergeResult, $isMerged, $msg );
$this->assertEquals( $expectedMergeAttemptResult, $mergeAttemptResult );
if ( $isMerged ) {
// Verify the merged text
$this->assertEquals( $expectedText, $mergedText,
'is merged text as expected?' );
}
}
public static function provideMerge() {
$EXPECT_MERGE_SUCCESS = true;
$EXPECT_MERGE_FAILURE = false;
return [
// #0: clean merge
[
// old:
"one one one\n" . // trimmed
"\n" .
"two two two",
// mine:
"one one one ONE ONE\n" .
"\n" .
"two two two\n", // with tailing whitespace
// yours:
"one one one\n" .
"\n" .
"two two TWO TWO", // trimmed
// ok:
$EXPECT_MERGE_SUCCESS,
// result:
"one one one ONE ONE\n" .
"\n" .
"two two TWO TWO\n", // note: will always end in a newline
// mergeAttemptResult:
"",
],
// #1: conflict, fail
[
// old:
"one one one", // trimmed
// mine:
"one one one ONE ONE\n" .
"\n" .
"bla bla\n" .
"\n", // with tailing whitespace
// yours:
"one one one\n" .
"\n" .
"two two", // trimmed
$EXPECT_MERGE_FAILURE,
// result:
null,
// mergeAttemptResult:
"1,3c\n" .
"one one one\n" .
"\n" .
"two two\n" .
".\n",
],
];
}
/**
* Same tests as the UrlUtils method to ensure they don't fall out of sync
* @dataProvider UrlUtilsProviders::provideMatchesDomainList
* @covers ::wfMatchesDomainList
*/
public function testWfMatchesDomainList( $url, $domains, $expected ) {
$actual = wfMatchesDomainList( $url, $domains );
$this->assertEquals( $expected, $actual );
}
/**
* @covers ::wfMkdirParents
*/
public function testWfMkdirParents() {
// Should not return true if file exists instead of directory
$fname = $this->getNewTempFile();
$this->assertFalse( @wfMkdirParents( $fname ) );
}
/**
* @dataProvider provideWfShellWikiCmdList
* @covers ::wfShellWikiCmd
*/
public function testWfShellWikiCmd( $script, $parameters, $options,
$expected, $description
) {
if ( wfIsWindows() ) {
// Approximation that's good enough for our purposes just now
$expected = str_replace( "'", '"', $expected );
}
$actual = wfShellWikiCmd( $script, $parameters, $options );
$this->assertEquals( $expected, $actual, $description );
}
public static function provideWfShellWikiCmdList() {
global $wgPhpCli;
return [
[ 'eval.php', [ '--help', '--test' ], [],
"'$wgPhpCli' 'eval.php' '--help' '--test'",
"Called eval.php --help --test" ],
[ 'eval.php', [ '--help', '--test space' ], [ 'php' => 'php5' ],
"'php5' 'eval.php' '--help' '--test space'",
"Called eval.php --help --test with php option" ],
[ 'eval.php', [ '--help', '--test', 'X' ], [ 'wrapper' => 'MWScript.php' ],
"'$wgPhpCli' 'MWScript.php' 'eval.php' '--help' '--test' 'X'",
"Called eval.php --help --test with wrapper option" ],
[
'eval.php',
[ '--help', '--test', 'y' ],
[ 'php' => 'php5', 'wrapper' => 'MWScript.php' ],
"'php5' 'MWScript.php' 'eval.php' '--help' '--test' 'y'",
"Called eval.php --help --test with wrapper and php option"
],
];
}
/* @todo many more! */
}
PK ! 9*^ ^ GlobalFunctions/READMEnu Iw This directory hold tests for includes/GlobalFunctions.php file
which is a pile of functions.
PK ! y y " GlobalFunctions/WfParseUrlTest.phpnu Iw overrideConfigValue( MainConfigNames::UrlProtocols, [
'//',
'http://',
'https://',
'file://',
'mailto:',
'news:',
] );
}
/**
* Same tests as the UrlUtils method
* @dataProvider UrlUtilsProviders::provideParse
*/
public function testWfParseUrl( $url, $parts ) {
$this->assertEquals(
$parts,
wfParseUrl( $url )
);
}
}
PK ! \=W ) GlobalFunctions/WfThumbIsStandardTest.phpnu Iw overrideConfigValues( [
MainConfigNames::ThumbLimits => [
100,
401
],
MainConfigNames::ImageLimits => [
[ 300, 225 ],
[ 800, 600 ],
],
] );
}
public static function provideThumbParams() {
return [
// Thumb limits
[
'Standard thumb width',
true,
[ 'width' => 100 ],
],
[
'Standard thumb width',
true,
[ 'width' => 401 ],
],
// wfThumbIsStandard should match Linker::processResponsiveImages
// in its rounding behaviour.
[
'Standard thumb width (HiDPI 1.5x) - incorrect rounding',
false,
[ 'width' => 601 ],
],
[
'Standard thumb width (HiDPI 1.5x)',
true,
[ 'width' => 602 ],
],
[
'Standard thumb width (HiDPI 2x)',
true,
[ 'width' => 802 ],
],
[
'Non-standard thumb width',
false,
[ 'width' => 300 ],
],
// Image limits
// Note: Image limits are measured as pairs. Individual values
// may be non-standard based on the aspect ratio.
[
'Standard image width/height pair',
true,
[ 'width' => 250, 'height' => 225 ],
],
[
'Standard image width/height pair',
true,
[ 'width' => 667, 'height' => 600 ],
],
[
'Standard image width where image does not fit aspect ratio',
false,
[ 'width' => 300 ],
],
[
'Implicit width from image width/height pair aspect ratio fit',
true,
// 2000x1800 fit inside 300x225 makes w=250
[ 'width' => 250 ],
],
[
'Height-only is always non-standard',
false,
[ 'height' => 225 ],
],
];
}
/**
* @dataProvider provideThumbParams
*/
public function testIsStandard( $message, $expected, $params ) {
$handlers = $this->getConfVar( MainConfigNames::ParserTestMediaHandlers );
$this->setService(
'MediaHandlerFactory',
new MediaHandlerFactory( new NullLogger(), $handlers )
);
$this->assertSame(
$expected,
wfThumbIsStandard( new FakeDimensionFile( [ 2000, 1800 ], 'image/jpeg' ), $params ),
$message
);
}
}
PK ! markTestSkipped(
'T209159: Anonymous pipe under Windows cannot withstand such a large amount of data'
);
}
// Test several times because it involves a race condition that may randomly succeed or fail
for ( $i = 0; $i < 10; $i++ ) {
$output = wfShellExec( 'printf "%-333333s" "*"' );
$this->assertEquals( 333333, strlen( $output ) );
}
}
}
PK ! (35 5 config/ConfigFactoryTest.phpnu Iw register( 'unittest', 'GlobalVarConfig::newInstance' );
$this->assertInstanceOf( GlobalVarConfig::class, $factory->makeConfig( 'unittest' ) );
}
public function testRegisterInvalid() {
$factory = new ConfigFactory();
$this->expectException( InvalidArgumentException::class );
$factory->register( 'invalid', 'Invalid callback' );
}
public function testRegisterInvalidInstance() {
$factory = new ConfigFactory();
$this->expectException( InvalidArgumentException::class );
$factory->register( 'invalidInstance', (object)[] );
}
public function testRegisterInstance() {
$config = GlobalVarConfig::newInstance();
$factory = new ConfigFactory();
$factory->register( 'unittest', $config );
$this->assertSame( $config, $factory->makeConfig( 'unittest' ) );
}
public function testRegisterAgain() {
$factory = new ConfigFactory();
$factory->register( 'unittest', 'GlobalVarConfig::newInstance' );
$config1 = $factory->makeConfig( 'unittest' );
$factory->register( 'unittest', 'GlobalVarConfig::newInstance' );
$config2 = $factory->makeConfig( 'unittest' );
$this->assertNotSame( $config1, $config2 );
}
public function testSalvage() {
$oldFactory = new ConfigFactory();
$oldFactory->register( 'foo', 'GlobalVarConfig::newInstance' );
$oldFactory->register( 'bar', 'GlobalVarConfig::newInstance' );
$oldFactory->register( 'quux', 'GlobalVarConfig::newInstance' );
// instantiate two of the three defined configurations
$foo = $oldFactory->makeConfig( 'foo' );
$bar = $oldFactory->makeConfig( 'bar' );
$quux = $oldFactory->makeConfig( 'quux' );
// define new config instance
$newFactory = new ConfigFactory();
$newFactory->register( 'foo', 'GlobalVarConfig::newInstance' );
$newFactory->register( 'bar', static function () {
return new HashConfig();
} );
// "foo" and "quux" are defined in the old and the new factory.
// The old factory has instances for "foo" and "bar", but not "quux".
$newFactory->salvage( $oldFactory );
$newFoo = $newFactory->makeConfig( 'foo' );
$this->assertSame( $foo, $newFoo, 'existing instance should be salvaged' );
$newBar = $newFactory->makeConfig( 'bar' );
$this->assertNotSame( $bar, $newBar, 'don\'t salvage if callbacks differ' );
// the new factory doesn't have quux defined, so the quux instance should not be salvaged
$this->expectException( ConfigException::class );
$newFactory->makeConfig( 'quux' );
}
public function testGetConfigNames() {
$factory = new ConfigFactory();
$factory->register( 'foo', 'GlobalVarConfig::newInstance' );
$factory->register( 'bar', new HashConfig() );
$this->assertEquals( [ 'foo', 'bar' ], $factory->getConfigNames() );
}
public function testMakeConfigWithCallback() {
$factory = new ConfigFactory();
$factory->register( 'unittest', 'GlobalVarConfig::newInstance' );
$conf = $factory->makeConfig( 'unittest' );
$this->assertInstanceOf( Config::class, $conf );
$this->assertSame( $conf, $factory->makeConfig( 'unittest' ) );
}
public function testMakeConfigWithObject() {
$factory = new ConfigFactory();
$conf = new HashConfig();
$factory->register( 'test', $conf );
$this->assertSame( $conf, $factory->makeConfig( 'test' ) );
}
public function testMakeConfigFallback() {
$factory = new ConfigFactory();
$factory->register( '*', 'GlobalVarConfig::newInstance' );
$conf = $factory->makeConfig( 'unittest' );
$this->assertInstanceOf( Config::class, $conf );
}
public function testMakeConfigWithNoBuilders() {
$factory = new ConfigFactory();
$this->expectException( ConfigException::class );
$factory->makeConfig( 'nobuilderregistered' );
}
public function testMakeConfigWithInvalidCallback() {
$factory = new ConfigFactory();
$factory->register( 'unittest', static function () {
return true; // Not a Config object
} );
$this->expectException( UnexpectedValueException::class );
$factory->makeConfig( 'unittest' );
}
public function testGetDefaultInstance() {
// NOTE: the global config factory returned here has been overwritten
// for operation in test mode. It may not reflect LocalSettings.
$factory = $this->getServiceContainer()->getConfigFactory();
$this->assertInstanceOf( Config::class, $factory->makeConfig( 'main' ) );
}
}
PK ! config/LoggedServiceOptions.phpnu Iw accessLog = &$accessLog;
if ( !$accessLog ) {
$accessLog = [ $keys, [] ];
}
parent::__construct( $keys, ...$args );
}
/**
* @param string $key
* @return mixed
*/
public function get( $key ) {
$this->accessLog[1][$key] = true;
return parent::get( $key );
}
}
PK ! - $ config/TestAllServiceOptionsUsed.phpnu Iw assertNotEmpty( self::$serviceOptionsAccessLog,
'You need to pass LoggedServiceOptions to your class instead of ServiceOptions ' .
'for TestAllServiceOptionsUsed to work.'
);
[ $expected, $actual ] = self::$serviceOptionsAccessLog;
$expected = array_diff( $expected, $expectedUnused );
$this->assertSame(
[],
array_diff( $expected, array_keys( $actual ) ),
"Some ServiceOptions keys were not accessed in tests. If they really aren't used, " .
"remove them from the class' option list. If they are used, add tests to cover them, " .
"or ignore the problem for now by passing them to assertAllServiceOptionsUsed() in " .
"its \$expectedUnused argument."
);
if ( $expectedUnused ) {
$this->markTestIncomplete( 'Some ServiceOptions keys are not yet accessed by tests: ' .
implode( ', ', $expectedUnused ) );
}
}
}
PK ! s s config/GlobalVarConfigTest.phpnu Iw assertInstanceOf( GlobalVarConfig::class, $config );
$this->setMwGlobals( 'wgBaz', 'somevalue' );
// Check prefix is set to 'wg'
$this->assertEquals( 'somevalue', $config->get( 'Baz' ) );
}
/**
* @dataProvider provideConstructor
*/
public function testConstructor( $prefix ) {
$var = $prefix . 'GlobalVarConfigTest';
$this->setMwGlobals( $var, 'testvalue' );
$config = new GlobalVarConfig( $prefix );
$this->assertInstanceOf( GlobalVarConfig::class, $config );
$this->assertEquals( 'testvalue', $config->get( 'GlobalVarConfigTest' ) );
}
public static function provideConstructor() {
return [
[ 'wg' ],
[ 'ef' ],
[ 'smw' ],
[ 'blahblahblahblah' ],
[ '' ],
];
}
public function testHas() {
$this->setMwGlobals( 'wgGlobalVarConfigTestHas', 'testvalue' );
$config = new GlobalVarConfig();
$this->assertTrue( $config->has( 'GlobalVarConfigTestHas' ) );
$this->assertFalse( $config->has( 'GlobalVarConfigTestNotHas' ) );
}
public static function provideGet() {
$set = [
'wgSomething' => 'default1',
'wgFoo' => 'default2',
'efVariable' => 'default3',
'BAR' => 'default4',
];
foreach ( $set as $var => $value ) {
$GLOBALS[$var] = $value;
}
return [
[ 'Something', 'wg', 'default1' ],
[ 'Foo', 'wg', 'default2' ],
[ 'Variable', 'ef', 'default3' ],
[ 'BAR', '', 'default4' ],
[ 'ThisGlobalWasNotSetAbove', 'wg', false ]
];
}
/**
* @dataProvider provideGet
* @param string $name
* @param string $prefix
* @param string $expected
*/
public function testGet( $name, $prefix, $expected ) {
$config = new GlobalVarConfig( $prefix );
if ( $expected === false ) {
$this->expectException( ConfigException::class );
$this->expectExceptionMessage( 'GlobalVarConfig::get: undefined option:' );
}
$this->assertEquals( $expected, $config->get( $name ) );
}
}
PK ! b http/MWHttpRequestTest.phpnu Iw assertSame( $expect, MWHttpRequest::isValidURI( $uri ), $message );
}
public function testSetReverseProxy() {
$req = TestingAccessWrapper::newFromObject(
MediaWikiServices::getInstance()->getHttpRequestFactory()->create( 'https://example.org/path?query=string' )
);
$req->setReverseProxy( 'http://localhost:1234' );
$this->assertSame( 'http://localhost:1234/path?query=string', $req->url );
$this->assertSame( 'example.org', $req->reqHeaders['Host'] );
}
public function testItInjectsTelemetryHeaders() {
$telemetry = $this->createMock( TelemetryHeadersInterface::class );
$telemetry->expects( $this->once() )
->method( 'getRequestHeaders' )
->willReturn( [
'X-Request-Id' => 'request_identifier',
'tracestate' => 'tracestate_value',
'traceparent' => 'traceparent_value',
] );
$httpRequest = $this->getMockForAbstractClass(
MWHttpRequest::class,
[
'http://localhost/test',
[
'timeout' => 30,
'connectTimeout' => 30
]
]
);
$httpRequest->addTelemetry( $telemetry );
$accessWrapper = TestingAccessWrapper::newFromObject( $httpRequest );
$requestHeaders = $accessWrapper->reqHeaders;
$this->assertEquals( 'request_identifier', $requestHeaders['X-Request-Id'] );
$this->assertEquals( 'tracestate_value', $requestHeaders['tracestate'] );
$this->assertEquals( 'traceparent_value', $requestHeaders['traceparent'] );
}
}
PK ! T http/GuzzleHttpRequestTest.phpnu Iw 1,
'connectTimeout' => 1
];
/**
* Placeholder url to use for various tests. This is never contacted, but we must use
* a url of valid format to avoid validation errors.
* @var string
*/
protected $exampleUrl = 'http://www.example.test';
/**
* Minimal example body text
* @var string
*/
protected $exampleBodyText = 'x';
/**
* For accumulating callback data for testing
* @var string
*/
protected $bodyTextReceived = '';
/**
* Callback: process a chunk of the result of a HTTP request
*
* @param mixed $req
* @param string $buffer
* @return int Number of bytes handled
*/
public function processHttpDataChunk( $req, $buffer ) {
$this->bodyTextReceived .= $buffer;
return strlen( $buffer );
}
public function testSuccess() {
$handler = HandlerStack::create( new MockHandler( [ new Response( 200, [
'status' => 200,
], $this->exampleBodyText ) ] ) );
$r = new GuzzleHttpRequest( $this->exampleUrl,
[ 'handler' => $handler ] + $this->timeoutOptions );
$r->execute();
$this->assertEquals( 200, $r->getStatus() );
$this->assertEquals( $this->exampleBodyText, $r->getContent() );
}
public function testSuccessConstructorCallback() {
$this->bodyTextReceived = '';
$handler = HandlerStack::create( new MockHandler( [ new Response( 200, [
'status' => 200,
], $this->exampleBodyText ) ] ) );
$r = new GuzzleHttpRequest( $this->exampleUrl, [
'callback' => [ $this, 'processHttpDataChunk' ],
'handler' => $handler,
] + $this->timeoutOptions );
$r->execute();
$this->assertEquals( 200, $r->getStatus() );
$this->assertEquals( $this->exampleBodyText, $this->bodyTextReceived );
}
public function testSuccessSetCallback() {
$this->bodyTextReceived = '';
$handler = HandlerStack::create( new MockHandler( [ new Response( 200, [
'status' => 200,
], $this->exampleBodyText ) ] ) );
$r = new GuzzleHttpRequest( $this->exampleUrl, [
'handler' => $handler,
] + $this->timeoutOptions );
$r->setCallback( [ $this, 'processHttpDataChunk' ] );
$r->execute();
$this->assertEquals( 200, $r->getStatus() );
$this->assertEquals( $this->exampleBodyText, $this->bodyTextReceived );
}
/**
* use a callback stream to pipe the mocked response data to our callback function
*/
public function testSuccessSink() {
$this->bodyTextReceived = '';
$handler = HandlerStack::create( new MockHandler( [ new Response( 200, [
'status' => 200,
], $this->exampleBodyText ) ] ) );
$r = new GuzzleHttpRequest( $this->exampleUrl, [
'handler' => $handler,
'sink' => new MWCallbackStream( [ $this, 'processHttpDataChunk' ] ),
] + $this->timeoutOptions );
$r->execute();
$this->assertEquals( 200, $r->getStatus() );
$this->assertEquals( $this->exampleBodyText, $this->bodyTextReceived );
}
public function testBadUrl() {
$r = new GuzzleHttpRequest( '', $this->timeoutOptions );
$s = $r->execute();
$this->assertSame( 0, $r->getStatus() );
$this->assertStatusMessage( 'http-invalid-url', $s );
}
public function testConnectException() {
$handler = HandlerStack::create( new MockHandler( [ new GuzzleHttp\Exception\ConnectException(
'Mock Connection Exception', new Request( 'GET', $this->exampleUrl )
) ] ) );
$r = new GuzzleHttpRequest( $this->exampleUrl,
[ 'handler' => $handler ] + $this->timeoutOptions );
$s = $r->execute();
$this->assertSame( 0, $r->getStatus() );
$this->assertStatusMessage( 'http-request-error', $s );
}
public function testTimeout() {
$handler = HandlerStack::create( new MockHandler( [ new GuzzleHttp\Exception\RequestException(
'Connection timed out', new Request( 'GET', $this->exampleUrl )
) ] ) );
$r = new GuzzleHttpRequest( $this->exampleUrl,
[ 'handler' => $handler ] + $this->timeoutOptions );
$s = $r->execute();
$this->assertSame( 0, $r->getStatus() );
$this->assertStatusMessage( 'http-timed-out', $s );
}
public function testNotFound() {
$handler = HandlerStack::create( new MockHandler( [ new Response( 404, [
'status' => '404',
] ) ] ) );
$r = new GuzzleHttpRequest( $this->exampleUrl,
[ 'handler' => $handler ] + $this->timeoutOptions );
$s = $r->execute();
$this->assertEquals( 404, $r->getStatus() );
$this->assertStatusMessage( 'http-bad-status', $s );
}
/*
* Test of POST requests header
*/
public function testPostBody() {
$container = [];
$history = Middleware::history( $container );
$stack = HandlerStack::create( new MockHandler( [ new Response() ] ) );
$stack->push( $history );
$client = new GuzzleHttpRequest( $this->exampleUrl, [
'method' => 'POST',
'handler' => $stack,
'post' => 'key=value',
] + $this->timeoutOptions );
$client->execute();
$request = $container[0]['request'];
$this->assertEquals( 'POST', $request->getMethod() );
$this->assertEquals( 'application/x-www-form-urlencoded',
$request->getHeader( 'Content-Type' )[0] );
}
/**
* Test POSTed multipart request body with custom content type
*/
public function testPostBodyContentType() {
$container = [];
$history = Middleware::history( $container );
$stack = HandlerStack::create( new MockHandler( [ new Response() ] ) );
$stack->push( $history );
$client = new GuzzleHttpRequest( $this->exampleUrl, [
'method' => 'POST',
'handler' => $stack,
'postData' => new \GuzzleHttp\Psr7\MultipartStream( [ [
'name' => 'a',
'contents' => 'b'
] ] ),
] + $this->timeoutOptions );
$client->setHeader( 'Content-Type', 'text/mwtest' );
$client->execute();
$request = $container[0]['request'];
$this->assertEquals( 'text/mwtest',
$request->getHeader( 'Content-Type' )[0] );
}
/*
* Test that cookies from CookieJar were sent in the outgoing request.
*/
public function testCookieSent() {
$domain = parse_url( $this->exampleUrl, PHP_URL_HOST );
$expectedCookies = [ 'cookie1' => 'value1', 'anothercookie' => 'secondvalue' ];
$jar = new CookieJar;
foreach ( $expectedCookies as $key => $val ) {
$jar->setCookie( $key, $val, [ 'domain' => $domain ] );
}
$container = [];
$history = Middleware::history( $container );
$stack = HandlerStack::create( new MockHandler( [ new Response() ] ) );
$stack->push( $history );
$client = new GuzzleHttpRequest( $this->exampleUrl, [
'method' => 'POST',
'handler' => $stack,
'post' => 'key=value',
] + $this->timeoutOptions );
$client->setCookieJar( $jar );
$client->execute();
$request = $container[0]['request'];
$this->assertEquals( [ 'cookie1=value1; anothercookie=secondvalue' ],
$request->getHeader( 'Cookie' ) );
}
/*
* Test that cookies returned by HTTP response were added back into the CookieJar.
*/
public function testCookieReceived() {
$handler = HandlerStack::create( new MockHandler( [ new Response( 200, [
'status' => 200,
'Set-Cookie' => [ 'cookie1=value1', 'anothercookie=secondvalue' ]
] ) ] ) );
$r = new GuzzleHttpRequest( $this->exampleUrl,
[ 'handler' => $handler ] + $this->timeoutOptions );
$r->execute();
$domain = parse_url( $this->exampleUrl, PHP_URL_HOST );
$this->assertEquals( 'cookie1=value1; anothercookie=secondvalue',
$r->getCookieJar()->serializeToHttpRequest( '/', $domain ) );
}
}
PK ! ֮9d d % Permissions/PermissionManagerTest.phpnu Iw ';
protected function setUp(): void {
parent::setUp();
$localZone = 'UTC';
$localOffset = date( 'Z' ) / 60;
$this->overrideConfigValues( [
MainConfigNames::BlockDisablesLogin => false,
MainConfigNames::Localtimezone => $localZone,
MainConfigNames::LocalTZoffset => $localOffset,
MainConfigNames::ImplicitRights => [
'limitabletest'
],
MainConfigNames::RevokePermissions => [
'formertesters' => [
'runtest' => true
]
],
MainConfigNames::AvailableRights => [
'test',
'runtest',
'writetest',
'nukeworld',
'modifytest',
'editmyoptions',
'editinterface',
// Interface admin
'editsitejs',
'edituserjs',
// Admin
'delete',
'undelete',
'deletedhistory',
'deletedtext',
]
] );
$this->setGroupPermissions( 'unittesters', 'test', true );
$this->setGroupPermissions( 'unittesters', 'runtest', true );
$this->setGroupPermissions( 'unittesters', 'writetest', false );
$this->setGroupPermissions( 'unittesters', 'nukeworld', false );
$this->setGroupPermissions( 'testwriters', 'test', true );
$this->setGroupPermissions( 'testwriters', 'writetest', true );
$this->setGroupPermissions( 'testwriters', 'modifytest', true );
$this->setGroupPermissions( '*', 'editmyoptions', true );
$this->setGroupPermissions( 'deleted-viewer', 'deletedhistory', true );
$this->setGroupPermissions( 'deleted-viewer', 'deletedtext', true );
$this->setGroupPermissions( 'deleted-viewer', 'viewsuppressed', true );
$this->setGroupPermissions( 'interface-admin', 'editinterface', true );
$this->setGroupPermissions( 'interface-admin', 'editsitejs', true );
$this->setGroupPermissions( 'interface-admin', 'edituserjs', true );
$this->setGroupPermissions( 'sysop', 'editinterface', true );
$this->setGroupPermissions( 'sysop', 'delete', true );
$this->setGroupPermissions( 'sysop', 'undelete', true );
$this->setGroupPermissions( 'sysop', 'deletedhistory', true );
$this->setGroupPermissions( 'sysop', 'deletedtext', true );
// Without this testUserBlock will use a non-English context on non-English MediaWiki
// installations (because of how Title::checkUserBlock is implemented) and fail.
RequestContext::resetMain();
$this->userName = 'Useruser';
$altUserName = 'Altuseruser';
date_default_timezone_set( $localZone );
/**
* TODO: We should provision title object(s) via providers not in here
* in order for us to avoid setting mInterwiki via reflection property.
*/
$this->title = Title::makeTitle( NS_MAIN, "Main Page" );
if ( !isset( $this->userUser ) || !( $this->userUser instanceof User ) ) {
$this->userUser = User::newFromName( $this->userName );
if ( !$this->userUser->getId() ) {
$this->userUser = User::createNew( $this->userName, [
"email" => "test@example.com",
"real_name" => "Test User" ] );
$this->userUser->load();
}
$this->altUser = User::newFromName( $altUserName );
if ( !$this->altUser->getId() ) {
$this->altUser = User::createNew( $altUserName, [
"email" => "alttest@example.com",
"real_name" => "Test User Alt" ] );
$this->altUser->load();
}
$this->anonUser = User::newFromId( 0 );
$this->user = $this->userUser;
}
}
protected function setTitle( $ns, $title = "Main_Page" ) {
$this->title = Title::makeTitle( $ns, $title );
}
protected function setUser( $userName = null ) {
if ( $userName === 'anon' ) {
$this->user = $this->anonUser;
} elseif ( $userName === null || $userName === $this->userName ) {
$this->user = $this->userUser;
} else {
$this->user = $this->altUser;
}
}
/**
* @dataProvider provideSpecialsAndNSPermissions
*/
public function testSpecialsAndNSPermissions(
$namespace,
$userPerms,
$namespaceProtection,
$expectedPermErrors,
$expectedUserCan
) {
$this->setUser( $this->userName );
$this->setTitle( $namespace );
$this->mergeMwGlobalArrayValue( 'wgNamespaceProtection', $namespaceProtection );
$this->overrideConfigValue(
MainConfigNames::NamespaceProtection,
$namespaceProtection + [ NS_MEDIAWIKI => 'editinterface' ]
);
$permissionManager = $this->getServiceContainer()->getPermissionManager();
$this->overrideUserPermissions( $this->user, $userPerms );
$this->assertEquals(
$expectedPermErrors,
$permissionManager->getPermissionErrors( 'bogus', $this->user, $this->title )
);
$this->assertSame(
$expectedUserCan,
$permissionManager->userCan( 'bogus', $this->user, $this->title )
);
}
public static function provideSpecialsAndNSPermissions() {
yield [
'namespace' => NS_SPECIAL,
'user permissions' => [],
'namespace protection' => [],
'expected permission errors' => [ [ 'badaccess-group0' ], [ 'ns-specialprotected' ] ],
'user can' => false,
];
yield [
'namespace' => NS_MAIN,
'user permissions' => [ 'bogus' ],
'namespace protection' => [],
'expected permission errors' => [],
'user can' => true,
];
yield [
'namespace' => NS_MAIN,
'user permissions' => [],
'namespace protection' => [],
'expected permission errors' => [ [ 'badaccess-group0' ] ],
'user can' => false,
];
yield [
'namespace' => NS_USER,
'user permissions' => [],
'namespace protection' => [ NS_USER => [ 'bogus' ] ],
'expected permission errors' => [ [ 'badaccess-group0' ], [ 'namespaceprotected', 'User', 'bogus' ] ],
'user can' => false,
];
yield [
'namespace' => NS_MEDIAWIKI,
'user permissions' => [ 'bogus' ],
'namespace protection' => [],
'expected permission errors' => [ [ 'protectedinterface', 'bogus' ] ],
'user can' => false,
];
yield [
'namespace' => NS_MAIN,
'user permissions' => [ 'bogus' ],
'namespace protection' => [],
'expected permission errors' => [],
'user can' => true,
];
}
public function testCascadingSourcesRestrictions() {
$this->setTitle( NS_MAIN, "Test page" );
$this->overrideUserPermissions( $this->user, [ "edit", "bogus", 'createpage' ] );
$rs = $this->getServiceContainer()->getRestrictionStore();
$wrapper = TestingAccessWrapper::newFromObject( $rs );
$wrapper->cache = [ CacheKeyHelper::getKeyForPage( $this->title ) => [
'cascade_sources' => [
[
Title::makeTitle( NS_MAIN, "Bogus" ),
Title::makeTitle( NS_MAIN, "UnBogus" )
],
[
"bogus" => [ 'bogus', "sysop", "protect", "" ],
],
[
Title::makeTitle( NS_MAIN, "Bogus" ),
Title::makeTitle( NS_MAIN, "UnBogus" )
],
[]
],
] ];
$permissionManager = $this->getServiceContainer()->getPermissionManager();
$this->assertFalse( $permissionManager->userCan( 'bogus', $this->user, $this->title ) );
$this->assertEquals( [
[ "cascadeprotected", 2, "* [[:Bogus]]\n* [[:UnBogus]]\n", 'bogus' ] ],
$permissionManager->getPermissionErrors(
'bogus', $this->user, $this->title ) );
$this->assertTrue( $permissionManager->userCan( 'edit', $this->user, $this->title ) );
$this->assertEquals(
[],
$permissionManager->getPermissionErrors( 'edit', $this->user, $this->title )
);
}
public function testCascadingSourcesRestrictionsForFile() {
$this->setTitle( NS_FILE, 'Test.jpg' );
$this->overrideUserPermissions( $this->user, [ 'edit', 'move', 'upload', 'movefile', 'createpage' ] );
$rs = $this->getServiceContainer()->getRestrictionStore();
$wrapper = TestingAccessWrapper::newFromObject( $rs );
$wrapper->cache = [ CacheKeyHelper::getKeyForPage( $this->title ) => [
'cascade_sources' => [
[
Title::makeTitle( NS_MAIN, 'FileTemplate' ),
Title::makeTitle( NS_MAIN, 'FileUser' )
],
[
'edit' => [ 'sysop' ],
],
[
Title::makeTitle( NS_MAIN, 'FileTemplate' )
],
[
Title::makeTitle( NS_MAIN, 'FileUser' )
]
],
] ];
$permissionManager = $this->getServiceContainer()->getPermissionManager();
$this->assertFalse( $permissionManager->userCan( 'upload', $this->user, $this->title ) );
$this->assertEquals( [
[ 'cascadeprotected', 2, "* [[:FileTemplate]]\n* [[:FileUser]]\n", 'upload' ] ],
$permissionManager->getPermissionErrors( 'upload', $this->user, $this->title )
);
$this->assertFalse( $permissionManager->userCan( 'move', $this->user, $this->title ) );
$this->assertEquals( [
[ 'cascadeprotected', 2, "* [[:FileTemplate]]\n* [[:FileUser]]\n", 'move' ] ],
$permissionManager->getPermissionErrors( 'move', $this->user, $this->title )
);
$this->assertFalse( $permissionManager->userCan( 'edit', $this->user, $this->title ) );
$this->assertEquals( [
[ 'cascadeprotected', 2, "* [[:FileTemplate]]\n* [[:FileUser]]\n", 'edit' ] ],
$permissionManager->getPermissionErrors( 'edit', $this->user, $this->title )
);
}
/**
* @dataProvider provideActionPermissions
*/
public function testActionPermissions(
$namespace,
$titleOverrides,
$action,
$userPerms,
$expectedPermErrors,
$expectedUserCan
) {
$this->setTitle( $namespace, "Test page" );
$this->overrideUserPermissions( $this->user, $userPerms );
$permissionManager = $this->getServiceContainer()->getPermissionManager();
$rs = $this->getServiceContainer()->getRestrictionStore();
$wrapper = TestingAccessWrapper::newFromObject( $rs );
$wrapper->cache = [ CacheKeyHelper::getKeyForPage( $this->title ) => [
'create_protection' => [
'permission' => $titleOverrides['protectedPermission'] ?? '',
'user' => $this->user->getId(),
'expiry' => 'infinity',
'reason' => 'test',
],
'has_cascading' => false,
// XXX This is bogus, restrictions won't be empty if there's create protection
'restrictions' => [],
] ];
if ( isset( $titleOverrides['interwiki'] ) ) {
$reflectedTitle = TestingAccessWrapper::newFromObject( $this->title );
$reflectedTitle->mInterwiki = $titleOverrides['interwiki'];
}
$this->assertEquals(
$expectedPermErrors,
$permissionManager->getPermissionErrors( $action, $this->user, $this->title )
);
$this->assertSame(
$expectedUserCan,
$permissionManager->userCan( $action, $this->user, $this->title )
);
}
public static function provideActionPermissions() {
// title overrides can include "protectedPermission" to override
// $title->mTitleProtection['permission'], and "interwiki" to override
// $title->mInterwiki, for the few cases those are needed
yield [
'namespace' => NS_MAIN,
'title overrides' => [],
'action' => 'create',
'user permissions' => [ 'createpage' ],
'expected permission errors' => [ [ 'titleprotected', 'Useruser', 'test' ] ],
'user can' => false,
];
yield [
'namespace' => NS_MAIN,
'title overrides' => [ 'protectedPermission' => 'editprotected' ],
'action' => 'create',
'user permissions' => [ 'createpage', 'protect' ],
'expected permission errors' => [ [ 'titleprotected', 'Useruser', 'test' ] ],
'user can' => false,
];
yield [
'namespace' => NS_MAIN,
'title overrides' => [ 'protectedPermission' => 'editprotected' ],
'action' => 'create',
'user permissions' => [ 'createpage', 'editprotected' ],
'expected permission errors' => [],
'user can' => true,
];
yield [
'namespace' => NS_MEDIA,
'title overrides' => [],
'action' => 'move',
'user permissions' => [ 'move' ],
'expected permission errors' => [ [ 'immobile-source-namespace', 'Media' ] ],
'user can' => false,
];
yield [
'namespace' => NS_HELP,
'title overrides' => [],
'action' => 'move',
'user permissions' => [ 'move' ],
'expected permission errors' => [],
'user can' => true,
];
yield [
'namespace' => NS_HELP,
'title overrides' => [ 'interwiki' => 'no' ],
'action' => 'move',
'user permissions' => [ 'move' ],
'expected permission errors' => [ [ 'immobile-source-page' ] ],
'user can' => false,
];
yield [
'namespace' => NS_MEDIA,
'title overrides' => [],
'action' => 'move-target',
'user permissions' => [ 'move' ],
'expected permission errors' => [ [ 'immobile-target-namespace', 'Media' ] ],
'user can' => false,
];
yield [
'namespace' => NS_HELP,
'title overrides' => [],
'action' => 'move-target',
'user permissions' => [ 'move' ],
'expected permission errors' => [],
'user can' => true,
];
yield [
'namespace' => NS_HELP,
'title overrides' => [ 'interwiki' => 'no' ],
'action' => 'move-target',
'user permissions' => [ 'move' ],
'expected permission errors' => [ [ 'immobile-target-page' ] ],
'user can' => false,
];
yield [
'namespace' => NS_MAIN,
'title overrides' => [],
'action' => 'edit',
'user permissions' => [ 'createpage', 'edit' ],
'expected permission errors' => [ [ 'titleprotected', 'Useruser', 'test' ] ],
'user can' => false,
];
yield [
'namespace' => NS_MAIN,
'title overrides' => [],
'action' => 'edit',
'user permissions' => [ 'edit' ],
'expected permission errors' => [ [ 'nocreate-loggedin' ] ],
'user can' => false,
];
}
public function testEditActionPermissionWithExistingPage() {
$title = $this->getExistingTestPage( 'test page' )->getTitle();
$permissionManager = $this->getServiceContainer()->getPermissionManager();
$this->overrideUserPermissions( $this->user, [ 'edit' ] );
$this->assertSame( [], $permissionManager->getPermissionErrors( 'edit', $this->user, $title ) );
$this->assertTrue( $permissionManager->userCan( 'edit', $this->user, $title ) );
}
public function testAutocreatePermissionsHack() {
$this->enableAutoCreateTempUser();
$this->overrideConfigValue( MainConfigNames::GroupPermissions, [
'*' => [ 'edit' => false ],
'temp' => [ 'edit' => true, 'createpage' => true ],
] );
$services = $this->getServiceContainer();
$permissionManager = $services->getPermissionManager();
$user = $services->getUserFactory()->newAnonymous();
$title = $this->getNonexistingTestPage()->getTitle();
$this->assertNotEmpty(
$permissionManager->getPermissionErrors(
'edit',
$user,
$title
)
);
$this->assertSame(
[],
$permissionManager->getPermissionErrors(
'edit',
$user,
$title,
PermissionManager::RIGOR_QUICK
)
);
}
/**
* @dataProvider provideTestCheckUserBlockActions
*/
public function testCheckUserBlockActions( $block, $restriction, $expected ) {
$this->overrideConfigValues( [
MainConfigNames::EmailConfirmToEdit => false,
MainConfigNames::EnablePartialActionBlocks => true,
] );
if ( $restriction ) {
$pageRestriction = new PageRestriction( 0, $this->title->getArticleID() );
$pageRestriction->setTitle( $this->title );
$block->setRestrictions( [ $pageRestriction ] );
}
$user = $this->createUserWithBlock( $block );
$this->overrideUserPermissions( $user, [
'createpage',
'edit',
'move',
'rollback',
'patrol',
'upload',
'purge'
] );
$permissionManager = $this->getServiceContainer()->getPermissionManager();
// Check that user is blocked or unblocked from specific actions using getPermissionErrors
foreach ( $expected as $action => $blocked ) {
$expectedErrorCount = $blocked ? 1 : 0;
$this->assertCount(
$expectedErrorCount,
$permissionManager->getPermissionErrors(
$action,
$user,
$this->title
),
"Number of permission errors for action \"$action\""
);
}
// Check that user is blocked or unblocked from specific actions using getApplicableBlock
foreach ( $expected as $action => $blocked ) {
$this->assertSame(
$blocked,
$permissionManager->getApplicableBlock(
$action,
$user,
PermissionManager::RIGOR_FULL,
$this->title,
null
) !== null,
"Block returned by getApplicableBlock() for action \"$action\""
);
}
// quickUserCan should ignore user blocks
$this->assertTrue(
$permissionManager->quickUserCan( 'move-target', $this->user, $this->title )
);
}
/**
* Create a user that is blocked in global state
*
* @param array $options $block
* @return User
*/
private function createUserWithBlock( $options = [] ) {
$newUser = new User();
$newUser->setId( 12345 );
$newUser->setName( 'BlockedUser' );
$this->installMockBlockManager( $options, $newUser );
return $newUser;
}
/**
* Regression test for T348451
*/
public function testGetApplicableBlockForSpecialPage() {
$block = new DatabaseBlock( [
'address' => '127.0.8.1',
'by' => new UserIdentityValue( 100, 'TestUser' ),
'auto' => true,
] );
$user = $this->createUserWithBlock( $block );
$title = Title::makeTitle( NS_SPECIAL, 'Blankpage' );
$this->overrideUserPermissions( $user, [
'createpage',
'edit',
] );
$permissionManager = $this->getServiceContainer()->getPermissionManager();
// The block is applicable even if the target page is a special page
// for which we cannot instantiate an Action object.
$this->assertSame(
$block,
$permissionManager->getApplicableBlock(
'edit',
$user,
PermissionManager::RIGOR_FULL,
$title,
null
)
);
}
/**
* Regression test for T350202
*/
public function testGetApplicableBlockForImplicitRight() {
$block = new DatabaseBlock( [
'address' => '127.0.8.1',
'by' => new UserIdentityValue( 100, 'TestUser' ),
'auto' => true,
] );
$user = $this->createUserWithBlock( $block );
$title = Title::makeTitle( NS_MAIN, 'Test' );
$permissionManager = $this->getServiceContainer()->getPermissionManager();
// The block is not applicable because the purge permission is implicit.
$this->assertNull(
$permissionManager->getApplicableBlock(
'purge',
$user,
PermissionManager::RIGOR_FULL,
$title,
null
)
);
}
public static function provideTestCheckUserBlockActions() {
return [
'Sitewide autoblock' => [
new DatabaseBlock( [
'address' => '127.0.8.1',
'by' => new UserIdentityValue( 100, 'TestUser' ),
'auto' => true,
] ),
false,
[
'edit' => true,
'move-target' => true,
'rollback' => true,
'patrol' => true,
'upload' => true,
'purge' => false,
]
],
'Sitewide block' => [
new DatabaseBlock( [
'address' => '127.0.8.1',
'by' => new UserIdentityValue( 100, 'TestUser' ),
] ),
false,
[
'edit' => true,
'move-target' => true,
'rollback' => true,
'patrol' => true,
'upload' => true,
'purge' => false,
]
],
'Partial block without restriction against this page' => [
new DatabaseBlock( [
'address' => '127.0.8.1',
'by' => new UserIdentityValue( 100, 'TestUser' ),
'sitewide' => false,
] ),
false,
[
'edit' => false,
'move-target' => false,
'rollback' => false,
'patrol' => false,
'upload' => false,
'purge' => false,
]
],
'Partial block with restriction against this page' => [
new DatabaseBlock( [
'address' => '127.0.8.1',
'by' => new UserIdentityValue( 100, 'TestUser' ),
'sitewide' => false,
] ),
true,
[
'edit' => true,
'move-target' => true,
'rollback' => true,
'patrol' => true,
'upload' => false,
'purge' => false,
]
],
'Partial block with action restriction against uploading' => [
( new DatabaseBlock( [
'address' => '127.0.8.1',
'by' => UserIdentityValue::newRegistered( 100, 'Test' ),
'sitewide' => false,
] ) )->setRestrictions( [
new ActionRestriction( 0, BlockActionInfo::ACTION_UPLOAD )
] ),
false,
[
'edit' => false,
'move-target' => false,
'rollback' => false,
'patrol' => false,
'upload' => true,
'purge' => false,
]
],
'System block' => [
new SystemBlock( [
'address' => '127.0.8.1',
'by' => 100,
'systemBlock' => 'test',
] ),
false,
[
'edit' => true,
'move-target' => true,
'rollback' => true,
'patrol' => true,
'upload' => true,
'purge' => false,
]
],
'No block' => [
null,
false,
[
'edit' => false,
'move-target' => false,
'rollback' => false,
'patrol' => false,
'upload' => false,
'purge' => false,
]
]
];
}
/**
* A test of the filter() calls in getApplicableBlock()
*/
public function testGetApplicableBlockCompositeFilter() {
$this->overrideConfigValues( [
MainConfigNames::EnablePartialActionBlocks => true,
] );
$blockOptions = [
'address' => '127.0.8.1',
'by' => UserIdentityValue::newRegistered( 100, 'Test' ),
'sitewide' => false,
];
$uploadBlock = new DatabaseBlock( $blockOptions );
$uploadBlock->setRestrictions( [
new ActionRestriction( 0, BlockActionInfo::ACTION_UPLOAD )
] );
$emailBlock = new DatabaseBlock(
[
'blockEmail' => true,
'sitewide' => true
] + $blockOptions
);
$page = $this->getExistingTestPage();
$page2 = $this->getExistingTestPage( __FUNCTION__ . ' page2' );
$pageBlock = new DatabaseBlock( $blockOptions );
$pageBlock->setRestrictions( [
new PageRestriction( 0, $page->getId() )
] );
$compositeBlock = new CompositeBlock( [
'originalBlocks' => [
$uploadBlock,
$emailBlock,
$pageBlock
]
] );
$user = $this->createUserWithBlock( $compositeBlock );
$permissionManager = $this->getServiceContainer()->getPermissionManager();
// The email block, being a sitewide block with an additional
// blockEmail option, also blocks upload.
// assertEquals() gives nicer failure messages than assertSame().
$this->assertEquals(
[ $uploadBlock, $emailBlock ],
$permissionManager->getApplicableBlock(
'upload', $user, PermissionManager::RIGOR_FULL, null, null
)->toArray()
);
// Emailing is only blocked by the email block
$this->assertEquals(
[ $emailBlock ],
$permissionManager->getApplicableBlock(
'sendemail', $user, PermissionManager::RIGOR_FULL, null, null
)->toArray()
);
// As for upload, the email block applies to sitewide editing
$this->assertEquals(
[ $emailBlock, $pageBlock ],
$permissionManager->getApplicableBlock(
'edit', $user, PermissionManager::RIGOR_FULL, $page->getTitle(), null
)->toArray()
);
// Test filtering by page -- we use $page2 so $pageBlock does not apply
$this->assertEquals(
[ $emailBlock ],
$permissionManager->getApplicableBlock(
'edit', $user, PermissionManager::RIGOR_FULL, $page2->getTitle(), null
)->toArray()
);
}
/**
* @dataProvider provideTestCheckUserBlockMessage
*/
public function testCheckUserBlockMessage( $blockType, $blockParams, $restriction, $expected ) {
$this->overrideConfigValue(
MainConfigNames::EmailConfirmToEdit, false
);
$block = new $blockType( array_merge( [
'address' => '127.0.8.1',
'by' => $this->user,
'reason' => 'Test reason',
'timestamp' => '20000101000000',
'expiry' => 0,
], $blockParams ) );
if ( $restriction ) {
$pageRestriction = new PageRestriction( 0, $this->title->getArticleID() );
$pageRestriction->setTitle( $this->title );
$block->setRestrictions( [ $pageRestriction ] );
}
$user = $this->createUserWithBlock( $block );
$this->overrideUserPermissions( $user, [ 'edit', 'createpage' ] );
$permissionManager = $this->getServiceContainer()->getPermissionManager();
$errors = $permissionManager->getPermissionErrors(
'edit',
$user,
$this->title
);
$this->assertEquals(
$expected['message'],
$errors[0][0]
);
}
public static function provideTestCheckUserBlockMessage() {
return [
'Sitewide autoblock' => [
DatabaseBlock::class,
[ 'auto' => true ],
false,
[
'message' => 'autoblockedtext',
],
],
'Sitewide block' => [
DatabaseBlock::class,
[],
false,
[
'message' => 'blockedtext',
],
],
'Partial block with restriction against this page' => [
DatabaseBlock::class,
[ 'sitewide' => false ],
true,
[
'message' => 'blockedtext-partial',
],
],
'System block' => [
SystemBlock::class,
[ 'systemBlock' => 'test' ],
false,
[
'message' => 'systemblockedtext',
],
],
];
}
/**
* @dataProvider provideTestCheckUserBlockEmailConfirmToEdit
*/
public function testCheckUserBlockEmailConfirmToEdit( $emailConfirmToEdit, $assertion ) {
$this->overrideConfigValues( [
MainConfigNames::EmailConfirmToEdit => $emailConfirmToEdit,
MainConfigNames::EmailAuthentication => true,
] );
$this->overrideUserPermissions( $this->user, [
'edit',
'move',
] );
$permissionManager = $this->getServiceContainer()->getPermissionManager();
$this->$assertion( [ 'confirmedittext' ],
$permissionManager->getPermissionErrors( 'edit', $this->user, $this->title ) );
// $wgEmailConfirmToEdit only applies to 'edit' action
$this->assertEquals( [],
$permissionManager->getPermissionErrors( 'move-target', $this->user, $this->title ) );
}
public static function provideTestCheckUserBlockEmailConfirmToEdit() {
return [
'User must confirm email to edit' => [
true,
'assertContains',
],
'User may edit without confirming email' => [
false,
'assertNotContains',
],
];
}
/**
* Determine that the passed-in permission does not get mixed up with
* an action of the same name.
*/
public function testCheckUserBlockActionPermission() {
$tester = $this->createMock( Action::class );
$tester->method( 'getName' )
->willReturn( 'tester' );
$tester->method( 'getRestriction' )
->willReturn( 'test' );
$tester->method( 'requiresUnblock' )
->willReturn( false );
$tester->method( 'requiresWrite' )
->willReturn( false );
$tester->method( 'needsReadRights' )
->willReturn( false );
$this->overrideConfigValues( [
MainConfigNames::Actions => [
'tester' => $tester,
],
MainConfigNames::GroupPermissions => [
'*' => [
'tester' => true,
],
],
] );
$user = $this->createUserWithBlock( new DatabaseBlock( [
'address' => '127.0.8.1',
'by' => $this->user,
] ) );
$this->assertCount( 1, $this->getServiceContainer()->getPermissionManager()
->getPermissionErrors( 'tester', $user, $this->title )
);
}
public function testBlockInstanceCache() {
// First, check the user isn't blocked
$user = $this->getMutableTestUser()->getUser();
$ut = Title::makeTitle( NS_USER_TALK, $user->getName() );
$this->assertNull( $user->getBlock( false ) );
$this->assertFalse( $this->getServiceContainer()->getPermissionManager()
->isBlockedFrom( $user, $ut ) );
// Block the user
$blocker = $this->getTestSysop()->getUser();
$block = new DatabaseBlock( [
'hideName' => true,
'allowUsertalk' => false,
'reason' => 'Because',
] );
$block->setTarget( $user );
$block->setBlocker( $blocker );
$blockStore = $this->getServiceContainer()->getDatabaseBlockStore();
$res = $blockStore->insertBlock( $block );
$this->assertTrue( (bool)$res['id'], 'Failed to insert block' );
// Clear cache and confirm it loaded the block properly
$user->clearInstanceCache();
$this->assertInstanceOf( DatabaseBlock::class, $user->getBlock( false ) );
$this->assertTrue( $this->getServiceContainer()->getPermissionManager()
->isBlockedFrom( $user, $ut ) );
// Unblock
$blockStore->deleteBlock( $block );
// Clear cache and confirm it loaded the not-blocked properly
$user->clearInstanceCache();
$this->assertNull( $user->getBlock( false ) );
$this->assertFalse( $this->getServiceContainer()->getPermissionManager()
->isBlockedFrom( $user, $ut ) );
}
/**
* @dataProvider provideIsBlockedFrom
* @param string|null $title Title to test.
* @param bool $expect Expected result from User::isBlockedFrom()
* @param array $options Additional test options:
* - 'blockAllowsUTEdit': (bool, default true) Value for $wgBlockAllowsUTEdit
* - 'allowUsertalk': (bool, default false) Passed to DatabaseBlock::__construct()
* - 'pageRestrictions': (array|null) If non-empty, page restriction titles for the block.
*/
public function testIsBlockedFrom( $title, $expect, array $options = [] ) {
$this->overrideConfigValue(
MainConfigNames::BlockAllowsUTEdit,
$options['blockAllowsUTEdit'] ?? true
);
$user = $this->getTestUser()->getUser();
if ( $title === self::USER_TALK_PAGE ) {
$title = $user->getTalkPage();
} else {
$title = Title::newFromText( $title );
}
$restrictions = [];
foreach ( $options['pageRestrictions'] ?? [] as $pagestr ) {
$page = $this->getExistingTestPage(
$pagestr === self::USER_TALK_PAGE ? $user->getTalkPage() : $pagestr
);
$restrictions[] = new PageRestriction( 0, $page->getId() );
}
foreach ( $options['namespaceRestrictions'] ?? [] as $ns ) {
$restrictions[] = new NamespaceRestriction( 0, $ns );
}
$block = new DatabaseBlock( [
'expiry' => wfTimestamp( TS_MW, wfTimestamp() + ( 40 * 60 * 60 ) ),
'allowUsertalk' => $options['allowUsertalk'] ?? false,
'sitewide' => !$restrictions,
] );
$block->setTarget( $user );
$block->setBlocker( $this->getTestSysop()->getUser() );
if ( $restrictions ) {
$block->setRestrictions( $restrictions );
}
$blockStore = $this->getServiceContainer()->getDatabaseBlockStore();
$blockStore->insertBlock( $block );
$this->assertSame( $expect, $this->getServiceContainer()->getPermissionManager()
->isBlockedFrom( $user, $title ) );
}
public static function provideIsBlockedFrom() {
return [
'Sitewide block, basic operation' => [ 'Test page', true ],
'Sitewide block, not allowing user talk' => [
self::USER_TALK_PAGE, true, [
'allowUsertalk' => false,
]
],
'Sitewide block, allowing user talk' => [
self::USER_TALK_PAGE, false, [
'allowUsertalk' => true,
]
],
'Sitewide block, allowing user talk but $wgBlockAllowsUTEdit is false' => [
self::USER_TALK_PAGE, true, [
'allowUsertalk' => true,
'blockAllowsUTEdit' => false,
]
],
'Partial block, blocking the page' => [
'Test page', true, [
'pageRestrictions' => [ 'Test page' ],
]
],
'Partial block, not blocking the page' => [
'Test page 2', false, [
'pageRestrictions' => [ 'Test page' ],
]
],
'Partial block, not allowing user talk but user talk page is not blocked' => [
self::USER_TALK_PAGE, false, [
'allowUsertalk' => false,
'pageRestrictions' => [ 'Test page' ],
]
],
'Partial block, allowing user talk but user talk page is blocked' => [
self::USER_TALK_PAGE, true, [
'allowUsertalk' => true,
'pageRestrictions' => [ self::USER_TALK_PAGE ],
]
],
'Partial block, user talk page is not blocked but $wgBlockAllowsUTEdit is false' => [
self::USER_TALK_PAGE, false, [
'allowUsertalk' => false,
'pageRestrictions' => [ 'Test page' ],
'blockAllowsUTEdit' => false,
]
],
'Partial block, user talk page is blocked and $wgBlockAllowsUTEdit is false' => [
self::USER_TALK_PAGE, true, [
'allowUsertalk' => true,
'pageRestrictions' => [ self::USER_TALK_PAGE ],
'blockAllowsUTEdit' => false,
]
],
'Partial user talk namespace block, not allowing user talk' => [
self::USER_TALK_PAGE, true, [
'allowUsertalk' => false,
'namespaceRestrictions' => [ NS_USER_TALK ],
]
],
'Partial user talk namespace block, allowing user talk' => [
self::USER_TALK_PAGE, false, [
'allowUsertalk' => true,
'namespaceRestrictions' => [ NS_USER_TALK ],
]
],
'Partial user talk namespace block, where $wgBlockAllowsUTEdit is false' => [
self::USER_TALK_PAGE, true, [
'allowUsertalk' => true,
'namespaceRestrictions' => [ NS_USER_TALK ],
'blockAllowsUTEdit' => false,
]
],
];
}
public function testGetUserPermissions() {
$user = $this->getTestUser( [ 'unittesters' ] )->getUser();
$rights = $this->getServiceContainer()->getPermissionManager()
->getUserPermissions( $user );
$this->assertContains( 'runtest', $rights );
$this->assertNotContains( 'writetest', $rights );
$this->assertNotContains( 'modifytest', $rights );
$this->assertNotContains( 'nukeworld', $rights );
}
public function testGetUserPermissionsHooks() {
$user = $this->getTestUser( [ 'unittesters', 'testwriters' ] )->getUser();
$userWrapper = TestingAccessWrapper::newFromObject( $user );
$permissionManager = $this->getServiceContainer()->getPermissionManager();
$rights = $permissionManager->getUserPermissions( $user );
$this->assertContains( 'test', $rights );
$this->assertContains( 'runtest', $rights );
$this->assertContains( 'writetest', $rights );
$this->assertNotContains( 'nukeworld', $rights );
// Add a hook manipluating the rights
$this->setTemporaryHook( 'UserGetRights', static function ( $user, &$rights ) {
$rights[] = 'nukeworld';
$rights = array_diff( $rights, [ 'writetest' ] );
} );
$permissionManager->invalidateUsersRightsCache( $user );
$rights = $permissionManager->getUserPermissions( $user );
$this->assertContains( 'test', $rights );
$this->assertContains( 'runtest', $rights );
$this->assertNotContains( 'writetest', $rights );
$this->assertContains( 'nukeworld', $rights );
// Add a Session that limits rights. We're mocking a stdClass because the Session
// class is final, and thus not mockable.
$mock = $this->getMockBuilder( stdClass::class )
->addMethods( [ 'getAllowedUserRights', 'deregisterSession', 'getSessionId' ] )
->getMock();
$mock->method( 'getAllowedUserRights' )->willReturn( [ 'test', 'writetest' ] );
$mock->method( 'getSessionId' )->willReturn(
new SessionId( str_repeat( 'X', 32 ) )
);
$session = TestUtils::getDummySession( $mock );
$mockRequest = $this->getMockBuilder( FauxRequest::class )
->onlyMethods( [ 'getSession' ] )
->getMock();
$mockRequest->method( 'getSession' )->willReturn( $session );
$userWrapper->mRequest = $mockRequest;
$this->resetServices();
$rights = $this->getServiceContainer()
->getPermissionManager()
->getUserPermissions( $user );
$this->assertContains( 'test', $rights );
$this->assertNotContains( 'runtest', $rights );
$this->assertNotContains( 'writetest', $rights );
$this->assertNotContains( 'nukeworld', $rights );
}
public function testUserHasRight() {
$permissionManager = $this->getServiceContainer()->getPermissionManager();
$result = $permissionManager->userHasRight(
$this->getTestUser( 'unittesters' )->getUser(),
'test'
);
$this->assertTrue( $result, 'right was granted to group, so should be allowed' );
$result = $permissionManager->userHasRight(
$this->getTestUser( 'unittesters' )->getUser(),
'limitabletest'
);
$this->assertTrue( $result, 'not granted, but listed as implicit' );
$result = $permissionManager->userHasRight(
$this->getTestUser( 'unittesters' )->getUser(),
'mailpassword'
);
$this->assertTrue( $result, 'not granted, but has a limit, so should be allowed' );
$result = $permissionManager->userHasRight(
$this->getTestUser( 'unittesters' )->getUser(),
'rollback'
);
$this->assertFalse( $result, 'not granted, has a limit but is listed as available, so should not be allowed' );
$result = $permissionManager->userHasRight(
$this->getTestUser( 'formertesters' )->getUser(),
'runtest'
);
$this->assertFalse( $result, 'not granted, should not be allowed' );
$result = $permissionManager->userHasRight(
$this->getTestUser( 'formertesters' )->getUser(),
''
);
$this->assertTrue( $result, 'empty action should always be granted' );
}
public function testIsEveryoneAllowed() {
$permissionManager = $this->getServiceContainer()->getPermissionManager();
$result = $permissionManager->isEveryoneAllowed( 'editmyoptions' );
$this->assertTrue( $result );
$result = $permissionManager->isEveryoneAllowed( 'test' );
$this->assertFalse( $result );
}
public function testAddTemporaryUserRights() {
$permissionManager = $this->getServiceContainer()->getPermissionManager();
$this->overrideUserPermissions( $this->user, [ 'read', 'edit' ] );
$this->assertEquals( [ 'read', 'edit' ], $permissionManager->getUserPermissions( $this->user ) );
$this->assertFalse( $permissionManager->userHasRight( $this->user, 'move' ) );
$scope = $permissionManager->addTemporaryUserRights( $this->user, [ 'move', 'delete' ] );
$this->assertEquals( [ 'read', 'edit', 'move', 'delete' ],
$permissionManager->getUserPermissions( $this->user ) );
$this->assertTrue( $permissionManager->userHasRight( $this->user, 'move' ) );
$scope2 = $permissionManager->addTemporaryUserRights( $this->user, [ 'delete', 'upload' ] );
$this->assertEquals( [ 'read', 'edit', 'move', 'delete', 'upload' ],
$permissionManager->getUserPermissions( $this->user ) );
ScopedCallback::consume( $scope );
$this->assertEquals( [ 'read', 'edit', 'delete', 'upload' ],
$permissionManager->getUserPermissions( $this->user ) );
ScopedCallback::consume( $scope2 );
$this->assertEquals( [ 'read', 'edit' ],
$permissionManager->getUserPermissions( $this->user ) );
$this->assertFalse( $permissionManager->userHasRight( $this->user, 'move' ) );
( function () use ( $permissionManager ) {
$scope = $permissionManager->addTemporaryUserRights( $this->user, 'move' );
$this->assertTrue( $permissionManager->userHasRight( $this->user, 'move' ) );
} )();
$this->assertFalse( $permissionManager->userHasRight( $this->user, 'move' ) );
}
public static function provideGetRestrictionLevels() {
return [
'No namespace restriction' => [ [ '', 'autoconfirmed', 'sysop' ], NS_TALK ],
'Restricted to autoconfirmed' => [ [ '', 'sysop' ], NS_MAIN ],
'Restricted to sysop' => [ [ '' ], NS_USER ],
'Restricted to someone in two groups' => [ [ '', 'sysop' ], 101 ],
'No special permissions' => [
[ '' ],
NS_TALK,
[]
],
'autoconfirmed' => [
[ '', 'autoconfirmed' ],
NS_TALK,
[ 'autoconfirmed' ]
],
'autoconfirmed revoked' => [
[ '' ],
NS_TALK,
[ 'autoconfirmed', 'noeditsemiprotected' ]
],
'sysop' => [
[ '', 'autoconfirmed', 'sysop' ],
NS_TALK,
[ 'sysop' ]
],
'sysop with autoconfirmed revoked (a bit silly)' => [
[ '', 'sysop' ],
NS_TALK,
[ 'sysop', 'noeditsemiprotected' ]
],
];
}
/**
* @dataProvider provideGetRestrictionLevels
*/
public function testGetRestrictionLevels( array $expected, $ns, ?array $userGroups = null ) {
$this->overrideConfigValues( [
MainConfigNames::GroupPermissions => [
'*' => [ 'edit' => true ],
'autoconfirmed' => [ 'editsemiprotected' => true ],
'sysop' => [
'editsemiprotected' => true,
'editprotected' => true,
],
'privileged' => [ 'privileged' => true ],
],
MainConfigNames::RevokePermissions => [
'noeditsemiprotected' => [ 'editsemiprotected' => true ],
],
MainConfigNames::NamespaceProtection => [
NS_MAIN => 'autoconfirmed',
NS_USER => 'sysop',
101 => [ 'editsemiprotected', 'privileged' ],
],
MainConfigNames::RestrictionLevels => [ '', 'autoconfirmed', 'sysop' ],
MainConfigNames::Autopromote => []
] );
$user = $userGroups === null ? null : $this->getTestUser( $userGroups )->getUser();
$this->assertSame( $expected, $this->getServiceContainer()
->getPermissionManager()
->getNamespaceRestrictionLevels( $ns, $user ) );
}
public function testGetAllPermissions() {
$this->overrideConfigValue( MainConfigNames::AvailableRights, [ 'test_right' ] );
$this->assertContains(
'test_right',
$this->getServiceContainer()
->getPermissionManager()
->getAllPermissions()
);
}
public function testAnonPermissionsNotClash() {
$user1 = User::newFromName( 'User1' );
$user2 = User::newFromName( 'User2' );
$pm = $this->getServiceContainer()->getPermissionManager();
$pm->overrideUserRightsForTesting( $user2, [] );
$this->assertNotSame( $pm->getUserPermissions( $user1 ), $pm->getUserPermissions( $user2 ) );
}
public function testAnonPermissionsNotClashOneRegistered() {
$user1 = User::newFromName( 'User1' );
$user2 = $this->getTestSysop()->getUser();
$pm = $this->getServiceContainer()->getPermissionManager();
$this->assertNotSame( $pm->getUserPermissions( $user1 ), $pm->getUserPermissions( $user2 ) );
}
/**
* Test delete-redirect checks for Special:MovePage
*/
public function testDeleteRedirect() {
$this->editPage( 'ExistentRedirect3', '#REDIRECT [[Existent]]' );
$page = Title::makeTitle( NS_MAIN, 'ExistentRedirect3' );
$pm = $this->getServiceContainer()->getPermissionManager();
$user = $this->getTestUser()->getUser();
$this->assertFalse( $pm->quickUserCan( 'delete-redirect', $user, $page ) );
$pm->overrideUserRightsForTesting( $user, 'delete-redirect' );
$this->assertTrue( $pm->quickUserCan( 'delete-redirect', $user, $page ) );
$this->assertArrayEquals( [], $pm->getPermissionErrors( 'delete-redirect', $user, $page ) );
}
/**
* Ensure normal admins can view deleted javascript, but not restore it
* See T202989
*/
public function testSysopInterfaceAdminRights() {
$interfaceAdmin = $this->getTestUser( [ 'interface-admin', 'sysop' ] )->getUser();
$admin = $this->getTestSysop()->getUser();
$permManager = $this->getServiceContainer()->getPermissionManager();
$userJs = Title::makeTitle( NS_USER, 'Example/common.js' );
$this->assertTrue( $permManager->userCan( 'delete', $admin, $userJs ) );
$this->assertTrue( $permManager->userCan( 'delete', $interfaceAdmin, $userJs ) );
$this->assertTrue( $permManager->userCan( 'deletedhistory', $admin, $userJs ) );
$this->assertTrue( $permManager->userCan( 'deletedhistory', $interfaceAdmin, $userJs ) );
$this->assertTrue( $permManager->userCan( 'deletedtext', $admin, $userJs ) );
$this->assertTrue( $permManager->userCan( 'deletedtext', $interfaceAdmin, $userJs ) );
$this->assertFalse( $permManager->userCan( 'undelete', $admin, $userJs ) );
$this->assertTrue( $permManager->userCan( 'undelete', $interfaceAdmin, $userJs ) );
}
/**
* Ensure specific users can view deleted contents regardless of Namespace
* Protection, but not restore it
* See T362536
*
* @dataProvider provideDeletedViewerRights
*/
public function testDeletedViewerRights(
$userGroup,
$userPerms,
$expectedUserCan
) {
$currentUser = $this->getTestUser( $userGroup )->getUser();
$permManager = $this->getServiceContainer()->getPermissionManager();
$targetPage = Title::makeTitle( NS_MEDIAWIKI, 'Example' );
foreach ( $userPerms as $userPerm ) {
$this->assertSame(
$expectedUserCan,
$permManager->userCan( $userPerm, $currentUser, $targetPage )
);
}
}
public static function provideDeletedViewerRights() {
yield [
'usergroup' => '*',
'user permissions' => [
'delete',
'deletedhistory',
'deletedtext',
'suppressrevision',
'undelete',
'viewsuppressed'
],
'user can' => false
];
yield [
'usergroup' => 'deleted-viewer',
'user permissions' => [
'delete',
'suppressrevision',
'undelete'
],
'user can' => false
];
yield [
'usergroup' => 'deleted-viewer',
'user permissions' => [
'deletedhistory',
'deletedtext',
'viewsuppressed'
],
'user can' => true
];
}
/**
* Regression test for T306358 -- proper page assertion when checking
* blocked status on a special page
*/
public function testBlockedFromNonProperPage() {
$page = Title::makeTitle( NS_SPECIAL, 'Blankpage' );
$pm = $this->getServiceContainer()->getPermissionManager();
$user = $this->getMockBuilder( User::class )
->onlyMethods( [ 'getBlock' ] )
->getMock();
$user->method( 'getBlock' )
->willReturn( new DatabaseBlock( [
'address' => '127.0.8.1',
'by' => $this->user,
] ) );
$errors = $pm->getPermissionErrors( 'test', $user, $page );
$this->assertNotEmpty( $errors );
}
/**
* Test interaction with $wgWhitelistRead.
*
* @dataProvider provideWhitelistRead
*/
public function testWhitelistRead( array $whitelist, string $title, bool $shouldAllow ) {
$this->overrideConfigValues( [
MainConfigNames::LanguageCode => 'es',
MainConfigNames::WhitelistRead => $whitelist,
] );
$this->setGroupPermissions( '*', 'read', false );
$title = Title::newFromText( $title );
$pm = $this->getServiceContainer()->getPermissionManager();
$errors = $pm->getPermissionErrors( 'read', new User, $title );
if ( $shouldAllow ) {
$this->assertSame( [], $errors );
} else {
$this->assertNotEmpty( $errors );
}
}
public static function provideWhitelistRead() {
yield 'no match' => [ [ 'Bar', 'Baz' ], 'Foo', false ];
yield 'match' => [ [ 'Bar', 'Foo', 'Baz' ], 'Foo', true ];
yield 'text form' => [ [ 'Foo bar' ], 'Foo_bar', true ];
yield 'dbkey form' => [ [ 'Foo_bar' ], 'Foo bar', true ];
yield 'local namespace' => [ [ 'Usuario:Foo' ], 'User:Foo', true ];
yield 'legacy mainspace' => [ [ ':Foo' ], 'Foo', true ];
yield 'local special' => [ [ 'Especial:Todas' ], 'Special:Allpages', true ];
}
/**
* @covers \MediaWiki\Permissions\PermissionManager::getPermissionErrors
*/
public function testGetPermissionErrors_ignoreErrors() {
$hookCallback = static function ( $title, $user, $action, &$result ) {
$result = [
[ 'ignore', 'param' ],
[ 'noignore', 'param' ],
'ignore',
'noignore',
new Message( 'ignore' ),
];
return false;
};
$this->setTemporaryHook( 'getUserPermissionsErrors', $hookCallback );
$pm = $this->getServiceContainer()->getPermissionManager();
$errors = $pm->getPermissionErrors(
'read',
$this->user,
$this->title,
$pm::RIGOR_QUICK,
[ 'ignore' ]
);
$this->assertSame( [
[ 'noignore', 'param' ],
[ 'noignore' ],
], $errors );
}
/**
* @covers \MediaWiki\Permissions\PermissionManager::checkQuickPermissions
*/
public function testGetPermissionErrors_objectFromHookResult() {
$msg = ApiMessage::create( 'mymessage', 'mymessagecode', [ 'mydata' => true ] );
$this->setTemporaryHook(
'TitleQuickPermissions',
static function ( $hookTitle, $hookUser, $hookAction, &$errors, $doExpensiveQueries, $short ) use ( $msg ) {
$errors[] = [ $msg ];
return false;
}
);
$pm = $this->getServiceContainer()->getPermissionManager();
$errorsStatus = $pm->getPermissionStatus( 'create', $this->user, $this->title );
$errorsArray = $pm->getPermissionErrors( 'create', $this->user, $this->title );
$this->assertSame(
[ $msg ],
$errorsStatus->getMessages(),
'getPermissionStatus() preserves ApiMessage objects'
);
}
public function testShouldLimitPermissionsForBlockedUserWhenBlockDisablesLogin(): void {
$this->overrideConfigValues( [
MainConfigNames::BlockDisablesLogin => true,
MainConfigNames::GroupPermissions => [
'*' => [ 'edit' => true ],
'user' => [ 'edit' => true, 'move' => true ],
'sysop' => [ 'block' => true ],
],
] );
$testUser = $this->getTestUser()->getUserIdentity();
$this->blockUser( $testUser );
$permissions = $this->getServiceContainer()->getPermissionManager()->getUserPermissions( $testUser );
$this->assertSame( [ 'edit' ], $permissions );
}
public function testShouldLimitPermissionsForBlockedUserShouldAllowPermissionChecksInGetUserBlock(): void {
$this->overrideConfigValues( [
MainConfigNames::BlockDisablesLogin => true,
MainConfigNames::GroupPermissions => [
'*' => [ 'edit' => true ],
'user' => [ 'edit' => true, 'move' => true ],
'sysop' => [ 'block' => true ],
],
] );
$testUser = $this->getTestUser()->getUserIdentity();
$hookRan = false;
$this->setTemporaryHook(
'GetUserBlock',
function ( UserIdentity $user ) use ( $testUser, &$hookRan ): void {
if ( $user->equals( $testUser ) ) {
// Trigger an arbitrary permissions check to verify that they do not cause an infinite loop
// when BlockDisablesLogin = true (T384197).
$this->getServiceContainer()->getPermissionManager()
->userHasRight( $user, 'test' );
$hookRan = true;
}
}
);
$testUser = $this->getTestUser()->getUserIdentity();
$this->blockUser( $testUser );
$permissions = $this->getServiceContainer()->getPermissionManager()->getUserPermissions( $testUser );
$this->assertSame( [ 'edit' ], $permissions );
$this->assertTrue( $hookRan );
}
/**
* Convenience function to block a given user.
* @param UserIdentity $user
* @return void
*/
private function blockUser( UserIdentity $user ): void {
$status = $this->getServiceContainer()
->getBlockUserFactory()
->newBlockUser( $user, $this->getTestSysop()->getAuthority(), 'infinity' )
->placeBlock();
$this->assertStatusGood( $status );
}
}
PK ! sE3 E3 MediaWikiServicesTest.phpnu Iw set( MainConfigNames::ServiceWiringFiles, $globalConfig->get( MainConfigNames::ServiceWiringFiles ) );
$testConfig->set( MainConfigNames::ConfigRegistry, $globalConfig->get( MainConfigNames::ConfigRegistry ) );
$testConfig->set( MainConfigNames::Hooks, [] );
return $testConfig;
}
/**
* @return MediaWikiServices
*/
private function newMediaWikiServices() {
$config = $this->newTestConfig();
$instance = new MediaWikiServices( $config );
// Load the default wiring from the specified files.
$wiringFiles = $config->get( MainConfigNames::ServiceWiringFiles );
$instance->loadWiringFiles( $wiringFiles );
return $instance;
}
private function newConfigWithMockWiring() {
$config = new HashConfig;
$config->set( MainConfigNames::ServiceWiringFiles, [ __DIR__ . '/MockServiceWiring.php' ] );
return $config;
}
public function testGetInstance() {
$services = MediaWikiServices::getInstance();
$this->assertInstanceOf( MediaWikiServices::class, $services );
}
public function testForceGlobalInstance() {
$newServices = $this->newMediaWikiServices();
$oldServices = MediaWikiServices::forceGlobalInstance( $newServices );
$this->assertInstanceOf( MediaWikiServices::class, $oldServices );
$this->assertNotSame( $oldServices, $newServices );
$theServices = MediaWikiServices::getInstance();
$this->assertSame( $theServices, $newServices );
MediaWikiServices::forceGlobalInstance( $oldServices );
$theServices = MediaWikiServices::getInstance();
$this->assertSame( $theServices, $oldServices );
}
public function testResetGlobalInstance() {
$newServices = $this->newMediaWikiServices();
$oldServices = MediaWikiServices::forceGlobalInstance( $newServices );
$service1 = $this->createMock( SalvageableService::class );
$service1->expects( $this->never() )
->method( 'salvage' );
$newServices->defineService(
'Test',
static function () use ( $service1 ) {
return $service1;
}
);
// force instantiation
$newServices->getService( 'Test' );
MediaWikiServices::resetGlobalInstance( $this->newTestConfig() );
$theServices = MediaWikiServices::getInstance();
$this->assertSame(
$service1,
$theServices->getService( 'Test' ),
'service definition should survive reset'
);
$this->assertNotSame( $theServices, $newServices );
$this->assertNotSame( $theServices, $oldServices );
MediaWikiServices::forceGlobalInstance( $oldServices );
}
public function testResetGlobalInstance_quick() {
$newServices = $this->newMediaWikiServices();
$oldServices = MediaWikiServices::forceGlobalInstance( $newServices );
$service1 = $this->createMock( SalvageableService::class );
$service1->expects( $this->never() )
->method( 'salvage' );
$service2 = $this->createMock( SalvageableService::class );
$service2->expects( $this->once() )
->method( 'salvage' )
->with( $service1 );
// sequence of values the instantiator will return
$instantiatorReturnValues = [
$service1,
$service2,
];
$newServices->defineService(
'Test',
static function () use ( &$instantiatorReturnValues ) {
return array_shift( $instantiatorReturnValues );
}
);
// force instantiation
$newServices->getService( 'Test' );
MediaWikiServices::resetGlobalInstance( $this->newTestConfig(), 'quick' );
$theServices = MediaWikiServices::getInstance();
$this->assertSame( $service2, $theServices->getService( 'Test' ) );
$this->assertNotSame( $theServices, $newServices );
$this->assertNotSame( $theServices, $oldServices );
MediaWikiServices::forceGlobalInstance( $oldServices );
}
public function testResetGlobalInstance_T263925() {
$newServices = $this->newMediaWikiServices();
$oldServices = MediaWikiServices::forceGlobalInstance( $newServices );
self::$mockServiceWiring = [
'HookContainer' => function ( MediaWikiServices $services ) {
return new HookContainer(
new StaticHookRegistry(
[],
[
'MediaWikiServices' => [
[
'handler' => [
'name' => 'test',
'factory' => static function () {
return new class implements MediaWikiServicesHook {
public function onMediaWikiServices( $services ) {
}
};
}
],
'deprecated' => false,
'extensionPath' => 'path'
],
]
],
[]
),
$this->createSimpleObjectFactory()
);
}
];
$newServices->redefineService( 'HookContainer',
self::$mockServiceWiring['HookContainer'] );
$newServices->getHookContainer()->run( 'MediaWikiServices', [ $newServices ] );
MediaWikiServices::resetGlobalInstance( $this->newConfigWithMockWiring(), 'quick' );
$this->assertTrue( true, 'expected no exception from above' );
self::$mockServiceWiring = [];
MediaWikiServices::forceGlobalInstance( $oldServices );
}
public function testDisableStorage() {
$newServices = $this->newMediaWikiServices();
$oldServices = MediaWikiServices::forceGlobalInstance( $newServices );
$lbFactory = $this->createMock( \Wikimedia\Rdbms\LBFactorySimple::class );
$newServices->redefineService(
'DBLoadBalancerFactory',
static function () use ( $lbFactory ) {
return $lbFactory;
}
);
$this->assertFalse( $newServices->isStorageDisabled() );
$newServices->disableStorage(); // should destroy DBLoadBalancerFactory
$this->assertTrue( $newServices->isStorageDisabled() );
try {
$newServices->getDBLoadBalancer()->getConnection( DB_REPLICA );
} catch ( RuntimeException $ex ) {
// ok, as expected
}
MediaWikiServices::forceGlobalInstance( $oldServices );
$newServices->destroy();
// This should work now.
MediaWikiServices::getInstance()->getDBLoadBalancer()->getConnection( DB_REPLICA );
// No exception was thrown, avoid being risky
$this->assertTrue( true );
}
public function testResetChildProcessServices() {
$newServices = $this->newMediaWikiServices();
$oldServices = MediaWikiServices::forceGlobalInstance( $newServices );
$service1 = $this->createMock( DestructibleService::class );
$service1->expects( $this->once() )
->method( 'destroy' );
$service2 = $this->createMock( DestructibleService::class );
$service2->expects( $this->never() )
->method( 'destroy' );
// sequence of values the instantiator will return
$instantiatorReturnValues = [
$service1,
$service2,
];
$newServices->defineService(
'Test',
static function () use ( &$instantiatorReturnValues ) {
return array_shift( $instantiatorReturnValues );
}
);
// force the service to become active, so we can check that it does get destroyed
$oldTestService = $newServices->getService( 'Test' );
MediaWikiServices::resetChildProcessServices();
$finalServices = MediaWikiServices::getInstance();
$newTestService = $finalServices->getService( 'Test' );
$this->assertNotSame( $oldTestService, $newTestService );
MediaWikiServices::forceGlobalInstance( $oldServices );
}
public function testResetServiceForTesting() {
$services = $this->newMediaWikiServices();
$serviceCounter = 0;
$services->defineService(
'Test',
function () use ( &$serviceCounter ) {
$serviceCounter++;
$service = $this->createMock( Wikimedia\Services\DestructibleService::class );
$service->expects( $this->once() )->method( 'destroy' );
return $service;
}
);
// This should do nothing. In particular, it should not create a service instance.
$services->resetServiceForTesting( 'Test' );
$this->assertSame( 0, $serviceCounter, 'No service instance should be created yet.' );
$oldInstance = $services->getService( 'Test' );
$this->assertSame( 1, $serviceCounter, 'A service instance should exit now.' );
// The old instance should be detached, and destroy() called.
$services->resetServiceForTesting( 'Test' );
$newInstance = $services->getService( 'Test' );
$this->assertNotSame( $oldInstance, $newInstance );
// Satisfy the expectation that destroy() is called also for the second service instance.
$newInstance->destroy();
}
public function testResetServiceForTesting_noDestroy() {
$services = $this->newMediaWikiServices();
$services->defineService(
'Test',
function () {
$service = $this->createMock( Wikimedia\Services\DestructibleService::class );
$service->expects( $this->never() )->method( 'destroy' );
return $service;
}
);
$oldInstance = $services->getService( 'Test' );
// The old instance should be detached, but destroy() not called.
$services->resetServiceForTesting( 'Test', false );
$newInstance = $services->getService( 'Test' );
$this->assertNotSame( $oldInstance, $newInstance );
}
public function provideGetters() {
$getServiceCases = self::provideGetService();
$getterCases = [];
// All getters should be named just like the service, with "get" added.
foreach ( $getServiceCases as $name => $case ) {
if ( $name[0] === '_' ) {
// Internal service, no getter
continue;
}
[ $service, $class ] = $case;
$getterCases[$name] = [
'get' . $service,
$class,
in_array( $service, self::DEPRECATED_SERVICES )
];
}
return $getterCases;
}
/**
* @dataProvider provideGetters
*/
public function testGetters( $getter, $type, $isDeprecated = false ) {
if ( $isDeprecated ) {
$this->hideDeprecated( MediaWikiServices::class . "::$getter" );
}
// Test against the default instance, since the dummy will not know the default services.
$services = MediaWikiServices::getInstance();
$service = $services->$getter();
$this->assertInstanceOf( $type, $service );
}
public static function provideGetService() {
global $IP;
$serviceList = require "$IP/includes/ServiceWiring.php";
$ret = [];
foreach ( $serviceList as $name => $callback ) {
$fun = new ReflectionFunction( $callback );
if ( !$fun->hasReturnType() ) {
throw new LogicException( 'All service callbacks must have a return type defined, ' .
"none found for $name" );
}
$returnType = $fun->getReturnType();
$ret[$name] = [ $name, $returnType->getName() ];
}
return $ret;
}
/**
* @dataProvider provideGetService
*/
public function testGetService( $name, $type ) {
// Test against the default instance, since the dummy will not know the default services.
$services = MediaWikiServices::getInstance();
$service = $services->getService( $name );
$this->assertInstanceOf( $type, $service );
}
public function testDefaultServiceInstantiation() {
// Check all services in the default instance, not a dummy instance!
// Note that we instantiate all services here, including any that
// were registered by extensions.
$services = MediaWikiServices::getInstance();
$names = $services->getServiceNames();
foreach ( $names as $name ) {
$this->assertTrue( $services->hasService( $name ) );
$service = $services->getService( $name );
$this->assertIsObject( $service );
}
}
public function testDefaultServiceWiringServicesHaveTests() {
global $IP;
$testedServices = array_keys( self::provideGetService() );
$allServices = array_keys( require "$IP/includes/ServiceWiring.php" );
$this->assertEquals(
[],
array_diff( $allServices, $testedServices ),
'The following services have not been added to MediaWikiServicesTest::provideGetService'
);
}
public function testGettersAreSorted() {
$methods = ( new ReflectionClass( MediaWikiServices::class ) )
->getMethods( ReflectionMethod::IS_STATIC | ReflectionMethod::IS_PUBLIC );
$names = array_map( static function ( $method ) {
return $method->getName();
}, $methods );
$serviceNames = array_map( static function ( $name ) {
return "get$name";
}, array_keys( self::provideGetService() ) );
$names = array_values( array_filter( $names, static function ( $name ) use ( $serviceNames ) {
return in_array( $name, $serviceNames );
} ) );
$sortedNames = $names;
natcasesort( $sortedNames );
$this->assertSame( $sortedNames, $names,
'Please keep service getters sorted alphabetically' );
}
}
PK ! GxY Y media/ExifBitmapTest.phpnu Iw overrideConfigValue( MainConfigNames::ShowEXIF, true );
$this->handler = new ExifBitmapHandler;
}
public static function provideIsFileMetadataValid() {
return [
'old broken' => [
ExifBitmapHandler::OLD_BROKEN_FILE,
ExifBitmapHandler::METADATA_COMPATIBLE
],
'broken' => [
ExifBitmapHandler::BROKEN_FILE,
ExifBitmapHandler::METADATA_GOOD
],
'invalid' => [
'Something Invalid Here.',
ExifBitmapHandler::METADATA_BAD
],
'good' => [
'a:16:{s:10:"ImageWidth";i:20;s:11:"ImageLength";i:20;s:13:"BitsPerSample";a:3:{i:0;i:8;i:1;i:8;i:2;i:8;}s:11:"Compression";i:5;s:25:"PhotometricInterpretation";i:2;s:16:"ImageDescription";s:17:"Created with GIMP";s:12:"StripOffsets";i:8;s:11:"Orientation";i:1;s:15:"SamplesPerPixel";i:3;s:12:"RowsPerStrip";i:64;s:15:"StripByteCounts";i:238;s:11:"XResolution";s:19:"1207959552/16777216";s:11:"YResolution";s:19:"1207959552/16777216";s:19:"PlanarConfiguration";i:1;s:14:"ResolutionUnit";i:2;s:22:"MEDIAWIKI_EXIF_VERSION";i:2;}',
ExifBitmapHandler::METADATA_GOOD
],
'old good' => [
'a:16:{s:10:"ImageWidth";i:20;s:11:"ImageLength";i:20;s:13:"BitsPerSample";a:3:{i:0;i:8;i:1;i:8;i:2;i:8;}s:11:"Compression";i:5;s:25:"PhotometricInterpretation";i:2;s:16:"ImageDescription";s:17:"Created with GIMP";s:12:"StripOffsets";i:8;s:11:"Orientation";i:1;s:15:"SamplesPerPixel";i:3;s:12:"RowsPerStrip";i:64;s:15:"StripByteCounts";i:238;s:11:"XResolution";s:19:"1207959552/16777216";s:11:"YResolution";s:19:"1207959552/16777216";s:19:"PlanarConfiguration";i:1;s:14:"ResolutionUnit";i:2;s:22:"MEDIAWIKI_EXIF_VERSION";i:1;}',
ExifBitmapHandler::METADATA_COMPATIBLE
],
// Handle metadata from paged tiff handler (gotten via instant commons) gracefully.
'paged tiff' => [
'a:6:{s:9:"page_data";a:1:{i:1;a:5:{s:5:"width";i:643;s:6:"height";i:448;s:5:"alpha";s:4:"true";s:4:"page";i:1;s:6:"pixels";i:288064;}}s:10:"page_count";i:1;s:10:"first_page";i:1;s:9:"last_page";i:1;s:4:"exif";a:9:{s:10:"ImageWidth";i:643;s:11:"ImageLength";i:448;s:11:"Compression";i:5;s:25:"PhotometricInterpretation";i:2;s:11:"Orientation";i:1;s:15:"SamplesPerPixel";i:4;s:12:"RowsPerStrip";i:50;s:19:"PlanarConfiguration";i:1;s:22:"MEDIAWIKI_EXIF_VERSION";i:1;}s:21:"TIFF_METADATA_VERSION";s:3:"1.4";}',
ExifBitmapHandler::METADATA_BAD
],
];
}
/** @dataProvider provideIsFileMetadataValid */
public function testIsFileMetadataValid( $serializedMetadata, $expected ) {
$file = $this->getMockFileWithMetadata( $serializedMetadata );
$res = $this->handler->isFileMetadataValid( $file );
$this->assertEquals( $expected, $res );
}
public function testConvertMetadataLatest() {
$metadata = [
'foo' => [ 'First', 'Second', '_type' => 'ol' ],
'MEDIAWIKI_EXIF_VERSION' => 2
];
$res = $this->handler->convertMetadataVersion( $metadata, 2 );
$this->assertEquals( $metadata, $res );
}
public function testConvertMetadataToOld() {
$metadata = [
'foo' => [ 'First', 'Second', '_type' => 'ol' ],
'bar' => [ 'First', 'Second', '_type' => 'ul' ],
'baz' => [ 'First', 'Second' ],
'fred' => 'Single',
'MEDIAWIKI_EXIF_VERSION' => 2,
];
$expected = [
'foo' => "\n#First\n#Second",
'bar' => "\n*First\n*Second",
'baz' => "\n*First\n*Second",
'fred' => 'Single',
'MEDIAWIKI_EXIF_VERSION' => 1,
];
$res = $this->handler->convertMetadataVersion( $metadata, 1 );
$this->assertEquals( $expected, $res );
}
public function testConvertMetadataSoftware() {
$metadata = [
'Software' => [ [ 'GIMP', '1.1' ] ],
'MEDIAWIKI_EXIF_VERSION' => 2,
];
$expected = [
'Software' => 'GIMP (Version 1.1)',
'MEDIAWIKI_EXIF_VERSION' => 1,
];
$res = $this->handler->convertMetadataVersion( $metadata, 1 );
$this->assertEquals( $expected, $res );
}
public function testConvertMetadataSoftwareNormal() {
$metadata = [
'Software' => [ "GIMP 1.2", "vim" ],
'MEDIAWIKI_EXIF_VERSION' => 2,
];
$expected = [
'Software' => "\n*GIMP 1.2\n*vim",
'MEDIAWIKI_EXIF_VERSION' => 1,
];
$res = $this->handler->convertMetadataVersion( $metadata, 1 );
$this->assertEquals( $expected, $res );
}
}
PK ! n media/FakeDimensionFile.phpnu Iw dimensions = $dimensions;
$this->mime = $mime;
}
public function getWidth( $page = 1 ) {
return $this->dimensions[0];
}
public function getHeight( $page = 1 ) {
return $this->dimensions[1];
}
public function mustRender() {
return $this->mustRender;
}
public function getPath() {
return '';
}
public function getMimeType() {
return $this->mime;
}
}
PK ! *~=J J media/DjVuTest.phpnu Iw isEnabled() ) {
$this->markTestSkipped(
'This test needs the installation of the ddjvu, djvutoxml and djvudump tools' );
}
$this->overrideConfigValue( MainConfigNames::DjvuUseBoxedCommand, true );
$this->handler = new DjVuHandler();
}
public function testGetSizeAndMetadata() {
$info = $this->handler->getSizeAndMetadata(
new TrivialMediaHandlerState, $this->filePath . '/LoremIpsum.djvu' );
$this->assertSame( 2480, $info['width'] );
$this->assertSame( 3508, $info['height'] );
$this->assertIsArray( $info['metadata']['data'] );
}
public function testInvalidFile() {
$this->assertEquals(
[ 'metadata' => [ 'error' => 'Error extracting metadata' ] ],
$this->handler->getSizeAndMetadata(
new TrivialMediaHandlerState, $this->filePath . '/some-nonexistent-file' ),
'Getting metadata for a nonexistent file should return false'
);
}
public function testPageCount() {
$file = $this->dataFile( 'LoremIpsum.djvu', 'image/x.djvu' );
$this->assertEquals(
5,
$this->handler->pageCount( $file ),
'Test file LoremIpsum.djvu should be detected as containing 5 pages'
);
}
public function testGetPageDimensions() {
$file = $this->dataFile( 'LoremIpsum.djvu', 'image/x.djvu' );
$this->assertSame(
[ 'width' => 2480, 'height' => 3508 ],
$this->handler->getPageDimensions( $file, 1 ),
'Page 1 of test file LoremIpsum.djvu should have a size of 2480 * 3508'
);
}
public function testGetPageText() {
$file = $this->dataFile( 'LoremIpsum.djvu', 'image/x.djvu' );
$this->assertSame(
// note: this also tests that the column/paragraph is detected and converted
"Lorem ipsum \n\n1 \n",
$this->handler->getPageText( $file, 1 ),
"Text layer of page 1 of file LoremIpsum.djvu should be 'Lorem ipsum \n\n1 \n'"
);
}
}
PK ! PAw w media/JpegPixelFormatTest.phpnu Iw markTestSkipped( "This test is only applicable when using ImageMagick thumbnailing" );
}
if ( !$wgUseImageResize ) {
$this->markTestSkipped( "This test is only applicable when using thumbnailing" );
}
$fmtStr = var_export( $pixelFormat, true );
$this->overrideConfigValue( MainConfigNames::JpegPixelFormat, $pixelFormat );
$file = $this->dataFile( $sourceFile, 'image/jpeg' );
$params = [
'width' => 320,
];
$thumb = $file->transform( $params, File::RENDER_NOW | File::RENDER_FORCE );
$this->assertTrue( !$thumb->isError(), "created JPEG thumbnail for pixel format $fmtStr" );
$path = $thumb->getLocalCopyPath();
$this->assertIsString( $path, "path returned for JPEG thumbnail for $fmtStr" );
$result = Shell::command( 'identify',
'-format',
'%[jpeg:sampling-factor]',
$path
)->execute();
$this->assertSame( 0,
$result->getExitCode(),
"ImageMagick's identify command should return success"
);
$expected = $samplingFactor;
$actual = trim( $result->getStdout() );
$this->assertEquals(
$expected,
$actual,
"IM identify expects JPEG chroma subsampling \"$expected\" for $fmtStr"
);
}
public static function providePixelFormats() {
return [
// From 4:4:4 source file
[
'yuv444.jpg',
false,
'1x1,1x1,1x1'
],
[
'yuv444.jpg',
'yuv444',
'1x1,1x1,1x1'
],
[
'yuv444.jpg',
'yuv422',
'2x1,1x1,1x1'
],
[
'yuv444.jpg',
'yuv420',
'2x2,1x1,1x1'
],
// From 4:2:0 source file
[
'yuv420.jpg',
false,
'2x2,1x1,1x1'
],
[
'yuv420.jpg',
'yuv444',
'1x1,1x1,1x1'
],
[
'yuv420.jpg',
'yuv422',
'2x1,1x1,1x1'
],
[
'yuv420.jpg',
'yuv420',
'2x2,1x1,1x1'
]
];
}
}
PK ! L$G media/MediaWikiMediaTestCase.phpnu Iw filePath = $this->getFilePath();
$containers = [ 'data' => $this->filePath ];
if ( $this->createsThumbnails() ) {
// We need a temp directory for the thumbnails
// the container is named 'temp-thumb' because it is the
// thumb directory for a repo named "temp".
$containers['temp-thumb'] = $this->getNewTempDirectory();
}
$this->backend = new FSFileBackend( [
'name' => 'localtesting',
'wikiId' => WikiMap::getCurrentWikiId(),
'containerPaths' => $containers,
'tmpDirectory' => $this->getNewTempDirectory(),
'obResetFunc' => static function () {
// do nothing, we need the output buffer in tests
}
] );
$this->repo = new FileRepo( $this->getRepoOptions() );
}
/**
* @return array Argument for FileRepo constructor
*/
protected function getRepoOptions() {
return [
'name' => 'temp',
'url' => 'http://localhost/thumbtest',
'backend' => $this->backend
];
}
/**
* The result of this method will set the file path to use,
* as well as the protected member $filePath
*
* @return string Path where files are
*/
protected function getFilePath() {
return __DIR__ . '/../../data/media/';
}
/**
* Will the test create thumbnails (and thus do we need to set aside
* a temporary directory for them?)
*
* Override this method if your test case creates thumbnails
*
* @return bool
*/
protected function createsThumbnails() {
return false;
}
/**
* Utility function: Get a new file object for a file on disk but not actually in db.
*
* File must be in the path returned by getFilePath()
* @param string $name File name
* @param string|false $type MIME type [optional]
* @return UnregisteredLocalFile
*/
protected function dataFile( $name, $type = false ) {
return new UnregisteredLocalFile( false, $this->repo,
"mwstore://localtesting/data/$name", $type );
}
/**
* Get a mock LocalFile with the specified metadata, specified as a
* serialized string. The metadata-related methods will return this
* metadata. The behaviour of the other methods is undefined.
*
* @since 1.37
* @param string $metadata
* @return LocalFile
*/
protected function getMockFileWithMetadata( $metadata ) {
return new class( $metadata ) extends LocalFile {
public function __construct( $metadata ) {
$this->loadMetadataFromString( $metadata );
$this->dataLoaded = true;
}
};
}
}
PK ! 34 media/XCFHandlerTest.phpnu Iw handler = new XCFHandler();
}
/**
* @param string $filename
* @param array $expected
* @dataProvider provideGetSizeAndMetadata
* @covers \XCFHandler::getSizeAndMetadata
*/
public function testGetSizeAndMetadata( $filename, $expected ) {
$file = $this->dataFile( $filename, 'image/x-xcf' );
$actual = $this->handler->getSizeAndMetadata( $file, $file->getLocalRefPath() );
$this->assertSame( $expected, $actual );
}
public static function provideGetSizeAndMetadata() {
return [
[
'80x60-2layers.xcf',
[
'width' => 80,
'height' => 60,
'bits' => 8,
'metadata' => [
'colorType' => 'truecolour-alpha',
]
],
],
[
'80x60-RGB.xcf',
[
'width' => 80,
'height' => 60,
'bits' => 8,
'metadata' => [
'colorType' => 'truecolour-alpha',
]
],
],
[
'80x60-Greyscale.xcf',
[
'width' => 80,
'height' => 60,
'bits' => 8,
'metadata' => [
'colorType' => 'greyscale-alpha',
]
]
],
];
}
/**
* @param string $metadata Serialized metadata
* @param int $expected One of the class constants of XCFHandler
* @dataProvider provideIsFileMetadataValid
* @covers \XCFHandler::isFileMetadataValid
*/
public function testIsFileMetadataValid( $metadata, $expected ) {
$actual = $this->handler->isFileMetadataValid( $this->getMockFileWithMetadata( $metadata ) );
$this->assertEquals( $expected, $actual );
}
public static function provideIsFileMetadataValid() {
return [
[ '', XCFHandler::METADATA_BAD ],
[ serialize( [ 'error' => true ] ), XCFHandler::METADATA_GOOD ],
[ false, XCFHandler::METADATA_BAD ],
[ serialize( [ 'colorType' => 'greyscale-alpha' ] ), XCFHandler::METADATA_GOOD ],
];
}
}
PK ! E y y media/TiffTest.phpnu Iw overrideConfigValue( MainConfigNames::ShowEXIF, true );
$this->handler = new TiffHandler;
}
/**
* @covers \TiffHandler::getSizeAndMetadata
*/
public function testInvalidFile() {
$res = $this->handler->getSizeAndMetadata( null, self::FILE_PATH . 'README' );
$this->assertEquals( [ 'metadata' => [ '_error' => ExifBitmapHandler::BROKEN_FILE ] ], $res );
}
/**
* @covers \TiffHandler::getSizeAndMetadata
*/
public function testTiffMetadataExtraction() {
$res = $this->handler->getSizeAndMetadata( null, self::FILE_PATH . 'test.tiff' );
$expected = [
'width' => 20,
'height' => 20,
'metadata' => [
'ImageWidth' => 20,
'ImageLength' => 20,
'BitsPerSample' => [
0 => 8,
1 => 8,
2 => 8,
],
'Compression' => 5,
'PhotometricInterpretation' => 2,
'ImageDescription' => 'Created with GIMP',
'StripOffsets' => 8,
'Orientation' => 1,
'SamplesPerPixel' => 3,
'RowsPerStrip' => 64,
'StripByteCounts' => 238,
'XResolution' => '1207959552/16777216',
'YResolution' => '1207959552/16777216',
'PlanarConfiguration' => 1,
'ResolutionUnit' => 2,
'MEDIAWIKI_EXIF_VERSION' => 2,
]
];
// Re-unserialize in case there are subtle differences between how versions
// of php serialize stuff.
$this->assertEquals( $expected, $res );
}
}
PK ! m % media/MediaHandlerIntegrationTest.phpnu Iw overrideConfigValue( MainConfigNames::LanguageCode, 'en' );
$testHandler = new class extends MediaHandler {
public function formatMetadata( $image, $context = false ) {
return $this->formatMetadataHelper( [
'UnitTestOverride' => 'abc',
'UnitTestDelete' => 'def',
'UnitTestOther' => '1234.5678',
], $context );
}
protected function formatTag( $key, $vals, $context = false ) {
if ( $key === 'UnitTestOverride' ) {
return 'Override';
} elseif ( $key === 'UnitTestDelete' ) {
return null;
} else {
return false;
}
}
public function getParamMap() {
throw new LogicException( 'should never get here' );
}
public function validateParam( $name, $value ) {
throw new LogicException( 'should never get here' );
}
public function makeParamString( $params ) {
throw new LogicException( 'should never get here' );
}
public function parseParamString( $str ) {
throw new LogicException( 'should never get here' );
}
public function normaliseParams( $image, &$params ) {
throw new LogicException( 'should never get here' );
}
public function getImageSize( $image, $path ) {
throw new LogicException( 'should never get here' );
}
public function doTransform( $image, $dstPath, $dstUrl, $params, $flags = 0 ) {
throw new LogicException( 'should never get here' );
}
};
$file = $this->dataFile( 'Tux.svg', 'image/svg+xml' );
$result = $testHandler->formatMetadata( $file );
$this->assertEqualsCanonicalizing( [
'visible' => [
],
'collapsed' => [
[
'id' => 'exif-unittestoverride',
'name' => 'unittestoverride',
// Note that formatTag overrode the formatted result here
'value' => 'Override'
],
[
'id' => 'exif-unittestother',
'name' => 'unittestother',
// Note that this value went through Language::formatNum()
'value' => '1,234.5678'
],
// Note that unittestdelete is missing as expected
],
], $result );
}
}
PK ! ki # media/BitmapMetadataHandlerTest.phpnu Iw overrideConfigValue( MainConfigNames::ShowEXIF, false );
}
/**
* Test if having conflicting metadata values from different
* types of metadata, that the right one takes precedence.
*
* Basically the file has IPTC and XMP metadata, the
* IPTC should override the XMP, except for the multilingual
* translation (to en) where XMP should win.
* @covers \BitmapMetadataHandler::Jpeg
* @requires extension exif
*/
public function testMultilingualCascade() {
$this->overrideConfigValue( MainConfigNames::ShowEXIF, true );
$meta = BitmapMetadataHandler::Jpeg( self::FILE_PATH .
'/Xmp-exif-multilingual_test.jpg' );
$expected = [
'x-default' => 'right(iptc)',
'en' => 'right translation',
'_type' => 'lang'
];
$this->assertArrayHasKey( 'ImageDescription', $meta,
'Did not extract any ImageDescription info?!' );
$this->assertEquals( $expected, $meta['ImageDescription'] );
}
/**
* Test for jpeg comments are being handled by
* BitmapMetadataHandler correctly.
*
* There's more extensive tests of comment extraction in
* JpegMetadataExtractorTests.php
* @covers \BitmapMetadataHandler::Jpeg
*/
public function testJpegComment() {
$meta = BitmapMetadataHandler::Jpeg( self::FILE_PATH .
'jpeg-comment-utf.jpg' );
$this->assertEquals( 'UTF-8 JPEG Comment — ¼',
$meta['JPEGFileComment'][0] );
}
/**
* Make sure a bad iptc block doesn't stop the other metadata
* from being extracted.
* @covers \BitmapMetadataHandler::Jpeg
*/
public function testBadIPTC() {
$meta = BitmapMetadataHandler::Jpeg( self::FILE_PATH .
'iptc-invalid-psir.jpg' );
$this->assertEquals( 'Created with GIMP', $meta['JPEGFileComment'][0] );
}
/**
* @covers \BitmapMetadataHandler::Jpeg
*/
public function testIPTCDates() {
$meta = BitmapMetadataHandler::Jpeg( self::FILE_PATH .
'iptc-timetest.jpg' );
// raw date is 2020:07:13 14:04:05+11:32
$this->assertEquals( '2020:07:14 01:36:05', $meta['DateTimeDigitized'] );
// raw date is 1997:03:02 03:01:02-03:00
$this->assertEquals( '1997:03:02 00:01:02', $meta['DateTimeOriginal'] );
$meta = BitmapMetadataHandler::Jpeg( self::FILE_PATH .
'iptc-timetest-invalid.jpg' );
// raw date is 1845:03:02 03:01:02-03:00
$this->assertEquals( '1845:03:02 00:01:02', $meta['DateTimeOriginal'] );
// raw date is 1942:07:13 25:05:02+00:00
$this->assertSame( '1942:07:14 01:05:02', $meta['DateTimeDigitized'] );
}
/**
* XMP data should take priority over iptc data
* when hash has been updated, but not when
* the hash is wrong.
* @covers \BitmapMetadataHandler::addMetadata
* @covers \BitmapMetadataHandler::getMetadataArray
*/
public function testMerging() {
$merger = new BitmapMetadataHandler();
$merger->addMetadata( [ 'foo' => 'xmp' ], 'xmp-general' );
$merger->addMetadata( [ 'bar' => 'xmp' ], 'xmp-general' );
$merger->addMetadata( [ 'baz' => 'xmp' ], 'xmp-general' );
$merger->addMetadata( [ 'fred' => 'xmp' ], 'xmp-general' );
$merger->addMetadata( [ 'foo' => 'iptc (hash)' ], 'iptc-good-hash' );
$merger->addMetadata( [ 'bar' => 'iptc (bad hash)' ], 'iptc-bad-hash' );
$merger->addMetadata( [ 'baz' => 'iptc (bad hash)' ], 'iptc-bad-hash' );
$merger->addMetadata( [ 'fred' => 'iptc (no hash)' ], 'iptc-no-hash' );
$merger->addMetadata( [ 'baz' => 'exif' ], 'exif' );
$actual = $merger->getMetadataArray();
$expected = [
'foo' => 'xmp',
'bar' => 'iptc (bad hash)',
'baz' => 'exif',
'fred' => 'xmp',
];
$this->assertEquals( $expected, $actual );
}
/**
* @covers \BitmapMetadataHandler::png
*/
public function testPNGXMP() {
$result = BitmapMetadataHandler::PNG( self::FILE_PATH . 'xmp.png' );
$expected = [
'width' => 50,
'height' => 50,
'frameCount' => 0,
'loopCount' => 1,
'duration' => 0,
'bitDepth' => 1,
'colorType' => 'index-coloured',
'metadata' => [
'SerialNumber' => '123456789',
'_MW_PNG_VERSION' => 1,
],
];
$this->assertEquals( $expected, $result );
}
/**
* @covers \BitmapMetadataHandler::png
*/
public function testPNGNative() {
$result = BitmapMetadataHandler::PNG( self::FILE_PATH . 'Png-native-test.png' );
$expected = 'http://example.com/url';
$this->assertEquals( $expected, $result['metadata']['Identifier']['x-default'] );
}
/**
* @covers \BitmapMetadataHandler::getTiffByteOrder
*/
public function testTiffByteOrder() {
$res = BitmapMetadataHandler::getTiffByteOrder( self::FILE_PATH . 'test.tiff' );
$this->assertEquals( 'LE', $res );
}
}
PK ! itj| media/JpegTest.phpnu Iw overrideConfigValue( MainConfigNames::ShowEXIF, true );
$this->handler = new JpegHandler;
}
public function testInvalidFile() {
$file = $this->dataFile( 'README', 'image/jpeg' );
$res = $this->handler->getSizeAndMetadataWithFallback( $file, $this->filePath . 'README' );
$this->assertEquals( [ '_error' => ExifBitmapHandler::BROKEN_FILE ], $res['metadata'] );
}
public function testJpegMetadataExtraction() {
$file = $this->dataFile( 'test.jpg', 'image/jpeg' );
$res = $this->handler->getSizeAndMetadataWithFallback( $file, $this->filePath . 'test.jpg' );
$expected = [
'ImageDescription' => 'Test file',
'XResolution' => '72/1',
'YResolution' => '72/1',
'ResolutionUnit' => 2,
'YCbCrPositioning' => 1,
'JPEGFileComment' => [
0 => 'Created with GIMP',
],
'MEDIAWIKI_EXIF_VERSION' => 2,
];
// Unserialize in case serialization format ever changes.
$this->assertEquals( $expected, $res['metadata'] );
}
/**
* @covers \JpegHandler::getCommonMetaArray
*/
public function testGetIndependentMetaArray() {
$file = $this->dataFile( 'test.jpg', 'image/jpeg' );
$res = $this->handler->getCommonMetaArray( $file );
$expected = [
'ImageDescription' => 'Test file',
'XResolution' => '72/1',
'YResolution' => '72/1',
'ResolutionUnit' => 2,
'YCbCrPositioning' => 1,
'JPEGFileComment' => [
'Created with GIMP',
],
];
$this->assertEquals( $expected, $res );
}
/**
* @dataProvider provideSwappingICCProfile
* @covers \JpegHandler::swapICCProfile
*/
public function testSwappingICCProfile(
$sourceFilename, $controlFilename, $newProfileFilename, $oldProfileName
) {
global $wgExiftool;
if ( !$wgExiftool || !is_file( $wgExiftool ) ) {
$this->markTestSkipped( "Exiftool not installed, cannot test ICC profile swapping" );
}
$this->overrideConfigValue( MainConfigNames::UseTinyRGBForJPGThumbnails, true );
$sourceFilepath = $this->filePath . $sourceFilename;
$controlFilepath = $this->filePath . $controlFilename;
$profileFilepath = $this->filePath . $newProfileFilename;
$filepath = $this->getNewTempFile();
copy( $sourceFilepath, $filepath );
$this->handler->swapICCProfile(
$filepath,
[ 'sRGB', '-' ],
[ $oldProfileName ],
$profileFilepath
);
$this->assertEquals(
sha1( file_get_contents( $filepath ) ),
sha1( file_get_contents( $controlFilepath ) )
);
}
public static function provideSwappingICCProfile() {
return [
// File with sRGB should end up with TinyRGB
[
'srgb.jpg',
'tinyrgb.jpg',
'tinyrgb.icc',
'sRGB IEC61966-2.1'
],
// File with TinyRGB should be left unchanged
[
'tinyrgb.jpg',
'tinyrgb.jpg',
'tinyrgb.icc',
'sRGB IEC61966-2.1'
],
// File without profile should end up with TinyRGB
[
'missingprofile.jpg',
'tinyrgb.jpg',
'tinyrgb.icc',
'sRGB IEC61966-2.1'
],
// Non-sRGB file should be left untouched
[
'adobergb.jpg',
'adobergb.jpg',
'tinyrgb.icc',
'sRGB IEC61966-2.1'
]
];
}
}
PK ! ZF~ ~ media/BitmapScalingTest.phpnu Iw overrideConfigValues( [
MainConfigNames::MaxImageArea => 1.25e7, // 3500x3500
MainConfigNames::CustomConvertCommand => 'dummy', // Set so that we don't get client side rendering
] );
}
/**
* @dataProvider provideNormaliseParams
* @covers \BitmapHandler::normaliseParams
*/
public function testNormaliseParams( $fileDimensions, $expectedParams, $params, $msg ) {
$file = new FakeDimensionFile( $fileDimensions );
$handler = new BitmapHandler;
$valid = $handler->normaliseParams( $file, $params );
$this->assertTrue( $valid );
$this->assertEquals( $expectedParams, $params, $msg );
}
public static function provideNormaliseParams() {
return [
/* Regular resize operations */
[
[ 1024, 768 ],
[
'width' => 512, 'height' => 384,
'physicalWidth' => 512, 'physicalHeight' => 384,
'page' => 1, 'interlace' => false,
],
[ 'width' => 512 ],
'Resizing with width set',
],
[
[ 1024, 768 ],
[
'width' => 512, 'height' => 384,
'physicalWidth' => 512, 'physicalHeight' => 384,
'page' => 1, 'interlace' => false,
],
[ 'width' => 512, 'height' => 768 ],
'Resizing with height set too high',
],
[
[ 1024, 768 ],
[
'width' => 512, 'height' => 384,
'physicalWidth' => 512, 'physicalHeight' => 384,
'page' => 1, 'interlace' => false,
],
[ 'width' => 1024, 'height' => 384 ],
'Resizing with height set',
],
/* Very tall images */
[
[ 1000, 100 ],
[
'width' => 5, 'height' => 1,
'physicalWidth' => 5, 'physicalHeight' => 1,
'page' => 1, 'interlace' => false,
],
[ 'width' => 5 ],
'Very wide image',
],
[
[ 100, 1000 ],
[
'width' => 1, 'height' => 10,
'physicalWidth' => 1, 'physicalHeight' => 10,
'page' => 1, 'interlace' => false,
],
[ 'width' => 1 ],
'Very high image',
],
[
[ 100, 1000 ],
[
'width' => 1, 'height' => 5,
'physicalWidth' => 1, 'physicalHeight' => 10,
'page' => 1, 'interlace' => false,
],
[ 'width' => 10, 'height' => 5 ],
'Very high image with height set',
],
/* Max image area */
[
[ 4000, 4000 ],
[
'width' => 5000, 'height' => 5000,
'physicalWidth' => 4000, 'physicalHeight' => 4000,
'page' => 1, 'interlace' => false,
],
[ 'width' => 5000 ],
'Bigger than max image size but doesn\'t need scaling',
],
/* Max interlace image area */
[
[ 4000, 4000 ],
[
'width' => 5000, 'height' => 5000,
'physicalWidth' => 4000, 'physicalHeight' => 4000,
'page' => 1, 'interlace' => false,
],
[ 'width' => 5000, 'interlace' => true ],
'Interlace bigger than max interlace area',
],
];
}
/**
* @covers \BitmapHandler::doTransform
*/
public function testTooBigImage() {
$file = new FakeDimensionFile( [ 4000, 4000 ] );
$handler = new BitmapHandler;
$params = [ 'width' => '3700' ]; // Still bigger than max size.
$this->assertEquals( TransformTooBigImageAreaError::class,
get_class( $handler->doTransform( $file, 'dummy path', '', $params ) ) );
}
/**
* @covers \BitmapHandler::doTransform
*/
public function testTooBigMustRenderImage() {
$file = new FakeDimensionFile( [ 4000, 4000 ] );
$file->mustRender = true;
$handler = new BitmapHandler;
$params = [ 'width' => '5000' ]; // Still bigger than max size.
$this->assertEquals( TransformTooBigImageAreaError::class,
get_class( $handler->doTransform( $file, 'dummy path', '', $params ) ) );
}
/**
* @covers \BitmapHandler::getImageArea
*/
public function testImageArea() {
$file = new FakeDimensionFile( [ 7, 9 ] );
$handler = new BitmapHandler;
$this->assertEquals( 63, $handler->getImageArea( $file ) );
}
}
PK ! 8! media/PNGHandlerTest.phpnu Iw handler = new PNGHandler();
}
/**
* @return array Expected metadata for a broken file. This tests backwards
* compatibility with existing DB rows, so can't be changed.
*/
private function brokenFile() {
return [ '_error' => '0' ];
}
/**
* @covers \PNGHandler::getSizeAndMetadata
*/
public function testInvalidFile() {
$res = $this->handler->getSizeAndMetadata( null, $this->filePath . '/README' );
$this->assertEquals(
[
'metadata' => $this->brokenFile()
],
$res );
}
/**
* @param string $filename Basename of the file to check
* @param bool $expected Expected result.
* @dataProvider provideIsAnimated
* @covers \PNGHandler::isAnimatedImage
*/
public function testIsAnimanted( $filename, $expected ) {
$file = $this->dataFile( $filename, 'image/png' );
$actual = $this->handler->isAnimatedImage( $file );
$this->assertEquals( $expected, $actual );
}
public static function provideIsAnimated() {
return [
[ 'Animated_PNG_example_bouncing_beach_ball.png', true ],
[ '1bit-png.png', false ],
];
}
/**
* @param string $filename
* @param int $expected Total image area
* @dataProvider provideGetImageArea
* @covers \PNGHandler::getImageArea
*/
public function testGetImageArea( $filename, $expected ) {
$file = $this->dataFile( $filename, 'image/png' );
$actual = $this->handler->getImageArea( $file );
$this->assertEquals( $expected, $actual );
}
public static function provideGetImageArea() {
return [
[ '1bit-png.png', 2500 ],
[ 'greyscale-png.png', 2500 ],
[ 'Png-native-test.png', 126000 ],
[ 'Animated_PNG_example_bouncing_beach_ball.png', 10000 ],
];
}
/**
* @param string $metadata Serialized metadata
* @param int $expected One of the class constants of PNGHandler
* @dataProvider provideIsMetadataValid
* @covers \PNGHandler::isFileMetadataValid
*/
public function testIsFileMetadataValid( $metadata, $expected ) {
$actual = $this->handler->isFileMetadataValid( $this->getMockFileWithMetadata( $metadata ) );
$this->assertEquals( $expected, $actual );
}
public static function provideIsMetadataValid() {
return [
[ '0', PNGHandler::METADATA_GOOD ],
[ '', PNGHandler::METADATA_BAD ],
[ 'a:0:{}', PNGHandler::METADATA_BAD ],
[ 'Something invalid!', PNGHandler::METADATA_BAD ],
[
'a:6:{s:10:"frameCount";i:0;s:9:"loopCount";i:1;s:8:"duration";d:0;s:8:"bitDepth";i:8;s:9:"colorType";s:10:"truecolour";s:8:"metadata";a:1:{s:15:"_MW_PNG_VERSION";i:1;}}',
PNGHandler::METADATA_GOOD
],
];
// phpcs:enable
}
/**
* @param string $filename
* @param string $expected Serialized array
* @dataProvider provideGetSizeAndMetadata
* @covers \PNGHandler::getSizeAndMetadata
*/
public function testGetSizeAndMetadata( $filename, $expected ) {
$file = $this->dataFile( $filename, 'image/png' );
$actual = $this->handler->getSizeAndMetadata( $file, "$this->filePath/$filename" );
$this->assertEquals( $expected, $actual );
}
public static function provideGetSizeAndMetadata() {
return [
[
'rgb-na-png.png',
[
'width' => 50,
'height' => 50,
'bits' => 8,
'metadata' => [
'frameCount' => 0,
'loopCount' => 1,
'duration' => 0.0,
'bitDepth' => 8,
'colorType' => 'truecolour',
'metadata' => [
'_MW_PNG_VERSION' => 1,
],
],
],
],
[
'xmp.png',
[
'width' => 50,
'height' => 50,
'bits' => 1,
'metadata' => [
'frameCount' => 0,
'loopCount' => 1,
'duration' => 0.0,
'bitDepth' => 1,
'colorType' => 'index-coloured',
'metadata' => [
'SerialNumber' => '123456789',
'_MW_PNG_VERSION' => 1,
],
]
]
],
];
}
/**
* @param string $filename
* @param array $expected Expected standard metadata
* @dataProvider provideGetIndependentMetaArray
* @covers \PNGHandler::getCommonMetaArray
*/
public function testGetIndependentMetaArray( $filename, $expected ) {
$file = $this->dataFile( $filename, 'image/png' );
$actual = $this->handler->getCommonMetaArray( $file );
$this->assertEquals( $expected, $actual );
}
public static function provideGetIndependentMetaArray() {
return [
[ 'rgb-na-png.png', [] ],
[ 'xmp.png',
[
'SerialNumber' => '123456789',
]
],
];
}
/**
* @param string $filename
* @param float $expectedLength
* @dataProvider provideGetLength
* @covers \PNGHandler::getLength
*/
public function testGetLength( $filename, $expectedLength ) {
$file = $this->dataFile( $filename, 'image/png' );
$actualLength = $file->getLength();
$this->assertEqualsWithDelta( $expectedLength, $actualLength, 0.00001 );
}
public static function provideGetLength() {
return [
[ 'Animated_PNG_example_bouncing_beach_ball.png', 1.5 ],
[ 'Png-native-test.png', 0.0 ],
[ 'greyscale-png.png', 0.0 ],
[ '1bit-png.png', 0.0 ],
];
}
}
PK ! rB`* `* media/WebPHandlerTest.phpnu Iw getNewTempFile();
// Put header into file
file_put_contents( $tempFileName, $header );
$this->assertEquals( $expectedResult, WebPHandler::extractMetadata( $tempFileName ) );
}
public static function provideTestExtractMetaData() {
return [
// Files from https://developers.google.com/speed/webp/gallery2
[ "\x52\x49\x46\x46\x90\x68\x01\x00\x57\x45\x42\x50\x56\x50\x38\x4C\x83\x68\x01\x00\x2F\x8F\x01\x4B\x10\x8D\x38\x6C\xDB\x46\x92\xE0\xE0\x82\x7B\x6C",
[ 'compression' => 'lossless', 'width' => 400, 'height' => 301 ] ],
[ "\x52\x49\x46\x46\x64\x5B\x00\x00\x57\x45\x42\x50\x56\x50\x38\x58\x0A\x00\x00\x00\x10\x00\x00\x00\x8F\x01\x00\x2C\x01\x00\x41\x4C\x50\x48\xE5\x0E",
[ 'compression' => 'unknown', 'animated' => false, 'transparency' => true, 'width' => 400, 'height' => 301 ] ],
[ "\x52\x49\x46\x46\xA8\x72\x00\x00\x57\x45\x42\x50\x56\x50\x38\x4C\x9B\x72\x00\x00\x2F\x81\x81\x62\x10\x8D\x40\x8C\x24\x39\x6E\x73\x73\x38\x01\x96",
[ 'compression' => 'lossless', 'width' => 386, 'height' => 395 ] ],
[ "\x52\x49\x46\x46\xE0\x42\x00\x00\x57\x45\x42\x50\x56\x50\x38\x58\x0A\x00\x00\x00\x10\x00\x00\x00\x81\x01\x00\x8A\x01\x00\x41\x4C\x50\x48\x56\x10",
[ 'compression' => 'unknown', 'animated' => false, 'transparency' => true, 'width' => 386, 'height' => 395 ] ],
[ "\x52\x49\x46\x46\x70\x61\x02\x00\x57\x45\x42\x50\x56\x50\x38\x4C\x63\x61\x02\x00\x2F\x1F\xC3\x95\x10\x8D\xC8\x72\xDB\xC8\x92\x24\xD8\x91\xD9\x91",
[ 'compression' => 'lossless', 'width' => 800, 'height' => 600 ] ],
[ "\x52\x49\x46\x46\x1C\x1D\x01\x00\x57\x45\x42\x50\x56\x50\x38\x58\x0A\x00\x00\x00\x10\x00\x00\x00\x1F\x03\x00\x57\x02\x00\x41\x4C\x50\x48\x25\x8B",
[ 'compression' => 'unknown', 'animated' => false, 'transparency' => true, 'width' => 800, 'height' => 600 ] ],
[ "\x52\x49\x46\x46\xFA\xC5\x00\x00\x57\x45\x42\x50\x56\x50\x38\x4C\xEE\xC5\x00\x00\x2F\xA4\x81\x28\x10\x8D\x40\x68\x24\xC9\x91\xA4\xAE\xF3\x97\x75",
[ 'compression' => 'lossless', 'width' => 421, 'height' => 163 ] ],
[ "\x52\x49\x46\x46\xF6\x5D\x00\x00\x57\x45\x42\x50\x56\x50\x38\x58\x0A\x00\x00\x00\x10\x00\x00\x00\xA4\x01\x00\xA2\x00\x00\x41\x4C\x50\x48\x38\x1A",
[ 'compression' => 'unknown', 'animated' => false, 'transparency' => true, 'width' => 421, 'height' => 163 ] ],
[ "\x52\x49\x46\x46\xC4\x96\x01\x00\x57\x45\x42\x50\x56\x50\x38\x4C\xB8\x96\x01\x00\x2F\x2B\xC1\x4A\x10\x11\x87\x6D\xDB\x48\x12\xFC\x60\xB0\x83\x24",
[ 'compression' => 'lossless', 'width' => 300, 'height' => 300 ] ],
[ "\x52\x49\x46\x46\x0A\x11\x01\x00\x57\x45\x42\x50\x56\x50\x38\x58\x0A\x00\x00\x00\x10\x00\x00\x00\x2B\x01\x00\x2B\x01\x00\x41\x4C\x50\x48\x67\x6E",
[ 'compression' => 'unknown', 'animated' => false, 'transparency' => true, 'width' => 300, 'height' => 300 ] ],
// Lossy files from https://developers.google.com/speed/webp/gallery1
[ "\x52\x49\x46\x46\x68\x76\x00\x00\x57\x45\x42\x50\x56\x50\x38\x20\x5C\x76\x00\x00\xD2\xBE\x01\x9D\x01\x2A\x26\x02\x70\x01\x3E\xD5\x4E\x97\x43\xA2",
[ 'compression' => 'lossy', 'width' => 550, 'height' => 368 ] ],
[ "\x52\x49\x46\x46\xB0\xEC\x00\x00\x57\x45\x42\x50\x56\x50\x38\x20\xA4\xEC\x00\x00\xB2\x4B\x02\x9D\x01\x2A\x26\x02\x94\x01\x3E\xD1\x50\x96\x46\x26",
[ 'compression' => 'lossy', 'width' => 550, 'height' => 404 ] ],
[ "\x52\x49\x46\x46\x7A\x19\x03\x00\x57\x45\x42\x50\x56\x50\x38\x20\x6E\x19\x03\x00\xB2\xF8\x09\x9D\x01\x2A\x00\x05\xD0\x02\x3E\xAD\x46\x99\x4A\xA5",
[ 'compression' => 'lossy', 'width' => 1280, 'height' => 720 ] ],
[ "\x52\x49\x46\x46\x44\xB3\x02\x00\x57\x45\x42\x50\x56\x50\x38\x20\x38\xB3\x02\x00\x52\x57\x06\x9D\x01\x2A\x00\x04\x04\x03\x3E\xA5\x44\x96\x49\x26",
[ 'compression' => 'lossy', 'width' => 1024, 'height' => 772 ] ],
[ "\x52\x49\x46\x46\x02\x43\x01\x00\x57\x45\x42\x50\x56\x50\x38\x20\xF6\x42\x01\x00\x12\xC0\x05\x9D\x01\x2A\x00\x04\xF0\x02\x3E\x79\x34\x93\x47\xA4",
[ 'compression' => 'lossy', 'width' => 1024, 'height' => 752 ] ],
// Animated file from https://groups.google.com/a/chromium.org/d/topic/blink-dev/Y8tRC4mdQz8/discussion
[ "\x52\x49\x46\x46\xD0\x0B\x02\x00\x57\x45\x42\x50\x56\x50\x38\x58\x0A\x00\x00\x00\x12\x00\x00\x00\x3F\x01\x00\x3F\x01\x00\x41\x4E",
[ 'compression' => 'unknown', 'animated' => true, 'transparency' => true, 'width' => 320, 'height' => 320 ] ],
// Error cases
[ '', false ],
[ ' ', false ],
[ 'RIFF ', false ],
[ 'RIFF1234WEBP ', false ],
[ 'RIFF1234WEBPVP8 ', false ],
[ 'RIFF1234WEBPVP8L ', false ],
];
// phpcs:enable
}
/**
* @dataProvider provideTestWithFileExtractMetaData
*/
public function testWithFileExtractMetaData( $filename, $expectedResult ) {
$this->assertEquals( $expectedResult, WebPHandler::extractMetadata( $filename ) );
}
public static function provideTestWithFileExtractMetaData() {
return [
[ __DIR__ . '/../../data/media/2_webp_ll.webp',
[
'compression' => 'lossless',
'width' => 386,
'height' => 395
]
],
[ __DIR__ . '/../../data/media/2_webp_a.webp',
[
'compression' => 'lossy',
'animated' => false,
'transparency' => true,
'width' => 386,
'height' => 395
]
],
];
}
/**
* @dataProvider provideTestGetSizeAndMetadata
*/
public function testGetSizeAndMetadata( $path, $expectedResult ) {
$handler = new WebPHandler();
$this->assertEquals( $expectedResult, $handler->getSizeAndMetadata( null, $path ) );
}
public static function provideTestGetSizeAndMetadata() {
return [
// Public domain files from https://developers.google.com/speed/webp/gallery2
[
__DIR__ . '/../../data/media/2_webp_a.webp',
[
'width' => 386,
'height' => 395,
'metadata' => [
'compression' => 'lossy',
'animated' => false,
'transparency' => true,
'width' => 386,
'height' => 395,
'metadata' => [
'_MW_WEBP_VERSION' => 2,
],
],
]
],
[
__DIR__ . '/../../data/media/2_webp_ll.webp',
[
'width' => 386,
'height' => 395,
'metadata' => [
'compression' => 'lossless',
'width' => 386,
'height' => 395,
'metadata' => [
'_MW_WEBP_VERSION' => 2,
],
],
]
],
[
__DIR__ . '/../../data/media/webp_animated.webp',
[
'width' => 300,
'height' => 225,
'metadata' => [
'compression' => 'unknown',
'animated' => true,
'transparency' => true,
'width' => 300,
'height' => 225,
'metadata' => [
'_MW_WEBP_VERSION' => 2,
],
],
]
],
[
__DIR__ . '/../../data/media/exif.webp',
[
'width' => 40,
'height' => 10,
'metadata' => [
'compression' => 'lossy',
'animated' => false,
'transparency' => false,
'width' => 40,
'height' => 10,
'metadata' => [
'_MW_WEBP_VERSION' => 2,
],
'media-metadata' => [
'GPSLatitude' => 88.51805555555555,
'GPSLongitude' => -21.12357,
'GPSAltitude' => -3.1415926530119025,
'GPSDOP' => '5/1',
'GPSVersionID' => '2.2.0.0'
]
]
]
],
// Using non-standard "Exif\0\0" prefix
[
__DIR__ . '/../../data/media/exif-prefix.webp',
[
'width' => 40,
'height' => 10,
'metadata' => [
'compression' => 'lossy',
'animated' => false,
'transparency' => false,
'width' => 40,
'height' => 10,
'metadata' => [
'_MW_WEBP_VERSION' => 2,
],
'media-metadata' => [
'GPSLatitude' => 88.51805555555555,
'GPSLongitude' => -21.12357,
'GPSAltitude' => -3.1415926530119025,
'GPSDOP' => '5/1',
'GPSVersionID' => '2.2.0.0'
]
]
]
],
// Using standard "xmp " fourcc
[
__DIR__ . '/../../data/media/xmp.webp',
[
'width' => 420,
'height' => 300,
'metadata' => [
'compression' => 'lossy',
'animated' => false,
'transparency' => false,
'width' => 420,
'height' => 300,
'metadata' => [
'_MW_WEBP_VERSION' => 2,
],
'media-metadata' => [
'ImageDescription' => [
'x-default' => 'An example image',
'en' => 'right translation',
'_type' => 'lang'
]
]
]
]
],
// Using the "xmp\0" fourcc (not standard "xmp ").
[
__DIR__ . '/../../data/media/xmp-null.webp',
[
'width' => 420,
'height' => 300,
'metadata' => [
'compression' => 'lossy',
'animated' => false,
'transparency' => false,
'width' => 420,
'height' => 300,
'metadata' => [
'_MW_WEBP_VERSION' => 2,
],
'media-metadata' => [
'ImageDescription' => [
'x-default' => 'Image with XMPnull byte fourcc',
'en' => 'right translation',
'_type' => 'lang'
]
]
]
]
],
// Containing both XMP and Exif
[
__DIR__ . '/../../data/media/xmp-exif.webp',
[
'width' => 420,
'height' => 300,
'metadata' => [
'compression' => 'lossy',
'animated' => false,
'transparency' => false,
'width' => 420,
'height' => 300,
'metadata' => [
'_MW_WEBP_VERSION' => 2,
],
'media-metadata' => [
'ImageDescription' => [
'x-default' => 'right(iptc)',
'en' => 'right translation',
'_type' => 'lang'
],
'XResolution' => '72/1',
'YResolution' => '72/1',
'ResolutionUnit' => 2,
'YCbCrPositioning' => 1,
]
]
]
],
// Error cases
[
__FILE__,
[ 'metadata' => [ '_error' => '0' ] ],
],
];
}
/**
* Tests the WebP MIME detection. This should really be a separate test, but sticking it
* here for now.
*
* @dataProvider provideTestGetMimeType
*/
public function testGuessMimeType( $path ) {
$mime = $this->getServiceContainer()->getMimeAnalyzer();
$this->assertEquals( 'image/webp', $mime->guessMimeType( $path, false ) );
}
public static function provideTestGetMimeType() {
return [
// Public domain files from https://developers.google.com/speed/webp/gallery2
[ __DIR__ . '/../../data/media/2_webp_a.webp' ],
[ __DIR__ . '/../../data/media/2_webp_ll.webp' ],
[ __DIR__ . '/../../data/media/webp_animated.webp' ],
];
}
}
/* Python code to extract a header and convert to PHP format:
* print '"%s"' % ''.implode( '\\x%02X' % ord(c) for c in urllib.urlopen(url).read(36) )
*/
PK ! 7 media/ExifTest.phpnu Iw overrideConfigValue( MainConfigNames::ShowEXIF, true );
}
public function testGPSExtraction() {
$filename = self::FILE_PATH . 'exif-gps.jpg';
$seg = JpegMetadataExtractor::segmentSplitter( $filename );
$exif = new Exif( $filename, $seg['byteOrder'] );
$data = $exif->getFilteredData();
$expected = [
'GPSLatitude' => 88.5180555556,
'GPSLongitude' => -21.12357,
'GPSAltitude' => -3.141592653,
'GPSDOP' => '5/1',
'GPSVersionID' => '2.2.0.0',
];
$this->assertEqualsWithDelta( $expected, $data, 0.0000000001 );
}
public function testUnicodeUserComment() {
$filename = self::FILE_PATH . 'exif-user-comment.jpg';
$seg = JpegMetadataExtractor::segmentSplitter( $filename );
$exif = new Exif( $filename, $seg['byteOrder'] );
$data = $exif->getFilteredData();
$expected = [
'UserComment' => 'test⁔comment',
];
$this->assertEquals( $expected, $data );
}
}
PK ! B # media/JpegMetadataExtractorTest.phpnu Iw assertEquals( [ 'UTF-8 JPEG Comment — ¼' ], $res['COM'] );
}
public static function provideUtf8Comment() {
return [
[ 'jpeg-comment-utf.jpg' ],
[ 'jpeg-padding-even.jpg' ],
[ 'jpeg-padding-odd.jpg' ],
];
}
/** The file is iso-8859-1, but it should get auto converted */
public function testIso88591Comment() {
$res = JpegMetadataExtractor::segmentSplitter( self::FILE_PATH . 'jpeg-comment-iso8859-1.jpg' );
$this->assertEquals( [ 'ISO-8859-1 JPEG Comment - ¼' ], $res['COM'] );
}
/** Comment values that are non-textual (random binary junk) should not be shown.
* The example test file has a comment with a 0x5 byte in it which is a control character
* and considered binary junk for our purposes.
*/
public function testBinaryCommentStripped() {
$res = JpegMetadataExtractor::segmentSplitter( self::FILE_PATH . 'jpeg-comment-binary.jpg' );
$this->assertSame( [], $res['COM'] );
}
/* Very rarely a file can have multiple comments.
* Order of comments is based on order inside the file.
*/
public function testMultipleComment() {
$res = JpegMetadataExtractor::segmentSplitter( self::FILE_PATH . 'jpeg-comment-multiple.jpg' );
$this->assertEquals( [ 'foo', 'bar' ], $res['COM'] );
}
public function testXMPExtraction() {
$res = JpegMetadataExtractor::segmentSplitter( self::FILE_PATH . 'jpeg-xmp-psir.jpg' );
$expected = file_get_contents( self::FILE_PATH . 'jpeg-xmp-psir.xmp' );
$this->assertEquals( $expected, $res['XMP'] );
}
public function testPSIRExtraction() {
$res = JpegMetadataExtractor::segmentSplitter( self::FILE_PATH . 'jpeg-xmp-psir.jpg' );
$expected = '50686f746f73686f7020332e30003842494d04040000000'
. '000181c02190004746573741c02190003666f6f1c020000020004';
$this->assertEquals( $expected, bin2hex( $res['PSIR'][0] ) );
}
public function testXMPExtractionNullChar() {
$res = JpegMetadataExtractor::segmentSplitter( self::FILE_PATH . 'jpeg-xmp-nullchar.jpg' );
$expected = file_get_contents( self::FILE_PATH . 'jpeg-xmp-psir.xmp' );
$this->assertEquals( $expected, $res['XMP'] );
}
public function testXMPExtractionAltAppId() {
$res = JpegMetadataExtractor::segmentSplitter( self::FILE_PATH . 'jpeg-xmp-alt.jpg' );
$expected = file_get_contents( self::FILE_PATH . 'jpeg-xmp-psir.xmp' );
$this->assertEquals( $expected, $res['XMP'] );
}
public function testIPTCHashComparisionNoHash() {
$segments = JpegMetadataExtractor::segmentSplitter( self::FILE_PATH . 'jpeg-xmp-psir.jpg' );
$res = JpegMetadataExtractor::doPSIR( $segments['PSIR'][0] );
$this->assertEquals( 'iptc-no-hash', $res );
}
public function testIPTCHashComparisionBadHash() {
$segments = JpegMetadataExtractor::segmentSplitter( self::FILE_PATH . 'jpeg-iptc-bad-hash.jpg' );
$res = JpegMetadataExtractor::doPSIR( $segments['PSIR'][0] );
$this->assertEquals( 'iptc-bad-hash', $res );
}
public function testIPTCHashComparisionGoodHash() {
$segments = JpegMetadataExtractor::segmentSplitter( self::FILE_PATH . 'jpeg-iptc-good-hash.jpg' );
$res = JpegMetadataExtractor::doPSIR( $segments['PSIR'][0] );
$this->assertEquals( 'iptc-good-hash', $res );
}
public function testExifByteOrder() {
$res = JpegMetadataExtractor::segmentSplitter( self::FILE_PATH . 'exif-user-comment.jpg' );
$expected = 'BE';
$this->assertEquals( $expected, $res['byteOrder'] );
}
public function testInfiniteRead() {
// test file truncated right after a segment, which previously
// caused an infinite loop looking for the next segment byte.
// Should get past infinite loop and throw in StringUtils::unpack()
$this->expectException( InvalidJpegException::class );
$res = JpegMetadataExtractor::segmentSplitter( self::FILE_PATH . 'jpeg-segment-loop1.jpg' );
}
public function testInfiniteRead2() {
// test file truncated after a segment's marker and size, which
// would cause a seek past end of file. Seek past end of file
// doesn't actually fail, but prevents further reading and was
// devolving into the previous case (testInfiniteRead).
$this->expectException( InvalidJpegException::class );
$res = JpegMetadataExtractor::segmentSplitter( self::FILE_PATH . 'jpeg-segment-loop2.jpg' );
}
}
PK ! media/FormatMetadataTest.phpnu Iw overrideConfigValues( [
MainConfigNames::LanguageCode => 'en',
MainConfigNames::ShowEXIF => true,
] );
}
/**
* @covers \File::formatMetadata
*/
public function testInvalidDate() {
$file = $this->dataFile( 'broken_exif_date.jpg', 'image/jpeg' );
// Throws an error if bug hit
$meta = $file->formatMetadata();
$this->assertIsArray( $meta, 'Valid metadata extracted' );
// Find date exif entry
$this->assertArrayHasKey( 'visible', $meta );
$dateIndex = null;
foreach ( $meta['visible'] as $i => $data ) {
if ( $data['id'] == 'exif-datetimeoriginal' ) {
$dateIndex = $i;
}
}
$this->assertNotNull( $dateIndex, 'Date entry exists in metadata' );
$this->assertSame( '0000:01:00 00:02:27',
$meta['visible'][$dateIndex]['value'],
'File with invalid date metadata (T31471)' );
}
/**
* @dataProvider provideResolveMultivalueValue
* @covers \FormatMetadata::resolveMultivalueValue
*/
public function testResolveMultivalueValue( $input, $output ) {
$formatMetadata = new FormatMetadata();
$class = new ReflectionClass( FormatMetadata::class );
$method = $class->getMethod( 'resolveMultivalueValue' );
$method->setAccessible( true );
$actualInput = $method->invoke( $formatMetadata, $input );
$this->assertEquals( $output, $actualInput );
}
public static function provideResolveMultivalueValue() {
return [
'nonArray' => [
'foo',
'foo'
],
'multiValue' => [
[ 'first', 'second', 'third', '_type' => 'ol' ],
'first'
],
'noType' => [
[ 'first', 'second', 'third' ],
'first'
],
'typeFirst' => [
[ '_type' => 'ol', 'first', 'second', 'third' ],
'first'
],
'multilang' => [
[
'en' => 'first',
'de' => 'Erste',
'_type' => 'lang'
],
[
'en' => 'first',
'de' => 'Erste',
'_type' => 'lang'
],
],
'multilang-multivalue' => [
[
'en' => [ 'first', 'second' ],
'de' => [ 'Erste', 'Zweite' ],
'_type' => 'lang'
],
[
'en' => 'first',
'de' => 'Erste',
'_type' => 'lang'
],
],
];
}
/**
* @dataProvider provideGetFormattedData
* @covers \FormatMetadata::getFormattedData
*/
public function testGetFormattedData( $input, $output ) {
$this->assertEquals( $output, FormatMetadata::getFormattedData( $input ) );
}
public static function provideGetFormattedData() {
return [
[
[ 'Software' => 'Adobe Photoshop CS6 (Macintosh)' ],
[ 'Software' => 'Adobe Photoshop CS6 (Macintosh)' ],
],
[
[ 'Software' => [ 'FotoWare FotoStation' ] ],
[ 'Software' => 'FotoWare FotoStation' ],
],
[
[ 'Software' => [ [ 'Capture One PRO', '3.7.7' ] ] ],
[ 'Software' => 'Capture One PRO (Version 3.7.7)' ],
],
[
[ 'Software' => [ [ 'FotoWare ColorFactory', '' ] ] ],
[ 'Software' => 'FotoWare ColorFactory (Version )' ],
],
[
[ 'Software' => [ 'x-default' => 'paint.net 4.0.12', '_type' => 'lang' ] ],
[ 'Software' => ''
],
],
[
// https://phabricator.wikimedia.org/T178130
// WebMHandler.php turns both 'muxingapp' & 'writingapp' to 'Software'
[ 'Software' => [ [ 'Lavf57.25.100' ], [ 'Lavf57.25.100' ] ] ],
[ 'Software' => "- Lavf57.25.100
\n- Lavf57.25.100
" ],
],
];
}
/**
* @covers \FormatMetadata::getPriorityLanguages
* @dataProvider provideGetPriorityLanguagesData
* @param string $language
* @param string[] $expected
*/
public function testGetPriorityLanguagesInternal_language_expect(
string $language,
array $expected
): void {
$formatMetadata = TestingAccessWrapper::newFromObject( new FormatMetadata() );
$context = $formatMetadata->getContext();
$context->setLanguage( $this->getServiceContainer()->getLanguageFactory()->getLanguage( $language ) );
$x = $formatMetadata->getPriorityLanguages();
$this->assertSame( $expected, $x );
}
public static function provideGetPriorityLanguagesData() {
return [
'LanguageMl' => [
'ml',
[ 'ml', 'en' ],
],
'LanguageEn' => [
'en',
[ 'en', 'en' ],
],
'LanguageQqx' => [
'qqx',
[ 'qqx', 'en' ],
],
];
}
}
PK ! [\ media/GIFHandlerTest.phpnu Iw handler = new GIFHandler();
}
/**
* @return array Unserialized metadata array for GIFHandler::BROKEN_FILE
*/
private function brokenFile(): array {
return [ '_error' => 0 ];
}
/**
* @covers \GIFHandler::getSizeAndMetadata
*/
public function testInvalidFile() {
$res = $this->handler->getSizeAndMetadata( null, $this->filePath . '/README' );
$this->assertEquals( $this->brokenFile(), $res['metadata'] );
}
/**
* @param string $filename Basename of the file to check
* @param bool $expected Expected result.
* @dataProvider provideIsAnimated
* @covers \GIFHandler::isAnimatedImage
*/
public function testIsAnimated( $filename, $expected ) {
$file = $this->dataFile( $filename, 'image/gif' );
$actual = $this->handler->isAnimatedImage( $file );
$this->assertEquals( $expected, $actual );
}
public static function provideIsAnimated() {
return [
[ 'animated.gif', true ],
[ 'nonanimated.gif', false ],
];
}
/**
* @param string $filename
* @param int $expected Total image area
* @dataProvider provideGetImageArea
* @covers \GIFHandler::getImageArea
*/
public function testGetImageArea( $filename, $expected ) {
$file = $this->dataFile( $filename, 'image/gif' );
$actual = $this->handler->getImageArea( $file, $file->getWidth(), $file->getHeight() );
$this->assertEquals( $expected, $actual );
}
public static function provideGetImageArea() {
return [
[ 'animated.gif', 5400 ],
[ 'nonanimated.gif', 1350 ],
];
}
/**
* @param string $metadata Serialized metadata
* @param int $expected One of the class constants of GIFHandler
* @dataProvider provideIsFileMetadataValid
* @covers \GIFHandler::isFileMetadataValid
*/
public function testIsFileMetadataValid( $metadata, $expected ) {
$file = $this->getMockFileWithMetadata( $metadata );
$actual = $this->handler->isFileMetadataValid( $file );
$this->assertEquals( $expected, $actual );
}
public static function provideIsFileMetadataValid() {
return [
[ '0', GIFHandler::METADATA_GOOD ],
[ '', GIFHandler::METADATA_BAD ],
[ 'a:0:{}', GIFHandler::METADATA_BAD ],
[ 'Something invalid!', GIFHandler::METADATA_BAD ],
[
'a:4:{s:10:"frameCount";i:1;s:6:"looped";b:0;s:8:"duration";d:0.1000000000000000055511151231257827021181583404541015625;s:8:"metadata";a:2:{s:14:"GIFFileComment";a:1:{i:0;s:35:"GIF test file ⁕ Created with GIMP";}s:15:"_MW_GIF_VERSION";i:1;}}',
GIFHandler::METADATA_GOOD
],
];
// phpcs:enable
}
/**
* @param string $filename
* @param array $expected Unserialized metadata
* @dataProvider provideGetSizeAndMetadata
* @covers \GIFHandler::getSizeAndMetadata
*/
public function testGetSizeAndMetadata( $filename, $expected ) {
$file = $this->dataFile( $filename, 'image/gif' );
$actual = $this->handler->getSizeAndMetadata( $file, "$this->filePath/$filename" );
$this->assertEquals( $expected, $actual );
}
public static function provideGetSizeAndMetadata() {
return [
[
'nonanimated.gif',
[
'width' => 45,
'height' => 30,
'bits' => 1,
'metadata' => [
'frameCount' => 1,
'looped' => false,
'duration' => 0.1,
'metadata' => [
'GIFFileComment' => [ 'GIF test file ⁕ Created with GIMP' ],
'_MW_GIF_VERSION' => 1,
],
],
]
],
[
'animated-xmp.gif',
[
'width' => 45,
'height' => 30,
'bits' => 1,
'metadata' => [
'frameCount' => 4,
'looped' => true,
'duration' => 2.4,
'metadata' => [
'Artist' => 'Bawolff',
'ImageDescription' => [
'x-default' => 'A file to test GIF',
'_type' => 'lang',
],
'SublocationDest' => 'The interwebs',
'GIFFileComment' => [
0 => 'GIƒ·test·file',
],
'_MW_GIF_VERSION' => 1,
],
],
],
],
];
// phpcs:enable
}
/**
* @param string $filename
* @param string $expected Serialized array
* @dataProvider provideGetIndependentMetaArray
* @covers \GIFHandler::getCommonMetaArray
*/
public function testGetIndependentMetaArray( $filename, $expected ) {
$file = $this->dataFile( $filename, 'image/gif' );
$actual = $this->handler->getCommonMetaArray( $file );
$this->assertEquals( $expected, $actual );
}
public static function provideGetIndependentMetaArray() {
return [
[ 'nonanimated.gif', [
'GIFFileComment' => [
'GIF test file ⁕ Created with GIMP',
],
] ],
[ 'animated-xmp.gif',
[
'Artist' => 'Bawolff',
'ImageDescription' => [
'x-default' => 'A file to test GIF',
'_type' => 'lang',
],
'SublocationDest' => 'The interwebs',
'GIFFileComment' =>
[
'GIƒ·test·file',
],
]
],
];
}
/**
* @param string $filename
* @param float $expectedLength
* @dataProvider provideGetLength
* @covers \GIFHandler::getLength
*/
public function testGetLength( $filename, $expectedLength ) {
$file = $this->dataFile( $filename, 'image/gif' );
$actualLength = $file->getLength();
$this->assertEqualsWithDelta( $expectedLength, $actualLength, 0.00001 );
}
public static function provideGetLength() {
return [
[ 'animated.gif', 2.4 ],
[ 'animated-xmp.gif', 2.4 ],
[ 'nonanimated', 0.0 ],
[ 'Bishzilla_blink.gif', 1.4 ],
];
}
}
PK ! i media/ExifRotationTest.phpnu Iw handler = new BitmapHandler();
$this->overrideConfigValues( [
MainConfigNames::ShowEXIF => true,
MainConfigNames::EnableAutoRotation => true,
] );
}
/**
* Mark this test as creating thumbnail files.
* @inheritDoc
*/
protected function createsThumbnails() {
return true;
}
/**
* @dataProvider provideFiles
*/
public function testMetadata( $name, $type, $info ) {
if ( !$this->handler->canRotate() ) {
$this->markTestSkipped( "This test needs a rasterizer that can auto-rotate." );
}
$file = $this->dataFile( $name, $type );
$this->assertEquals( $info['width'], $file->getWidth(), "$name: width check" );
$this->assertEquals( $info['height'], $file->getHeight(), "$name: height check" );
}
/**
* Same as before, but with auto-rotation set to auto.
*
* This sets scaler to image magick, which we should detect as
* supporting rotation.
* @dataProvider provideFiles
*/
public function testMetadataAutoRotate( $name, $type, $info ) {
$this->overrideConfigValues( [
MainConfigNames::EnableAutoRotation => null,
MainConfigNames::UseImageMagick => true,
MainConfigNames::UseImageResize => true,
] );
$file = $this->dataFile( $name, $type );
$this->assertEquals( $info['width'], $file->getWidth(), "$name: width check" );
$this->assertEquals( $info['height'], $file->getHeight(), "$name: height check" );
}
/**
* @dataProvider provideFiles
*/
public function testRotationRendering( $name, $type, $info, $thumbs ) {
if ( !$this->handler->canRotate() ) {
$this->markTestSkipped( "This test needs a rasterizer that can auto-rotate." );
}
foreach ( $thumbs as $size => $out ) {
if ( preg_match( '/^(\d+)px$/', $size, $matches ) ) {
$params = [
'width' => $matches[1],
];
} elseif ( preg_match( '/^(\d+)x(\d+)px$/', $size, $matches ) ) {
$params = [
'width' => $matches[1],
'height' => $matches[2]
];
} else {
throw new InvalidArgumentException( 'bogus test data format ' . $size );
}
$file = $this->dataFile( $name, $type );
$thumb = $file->transform( $params, File::RENDER_NOW | File::RENDER_FORCE );
$this->assertEquals(
$out[0],
$thumb->getWidth(),
"$name: thumb reported width check for $size"
);
$this->assertEquals(
$out[1],
$thumb->getHeight(),
"$name: thumb reported height check for $size"
);
$gis = getimagesize( $thumb->getLocalCopyPath() );
if ( $out[0] > $info['width'] ) {
// Physical image won't be scaled bigger than the original.
$this->assertEquals( $info['width'], $gis[0], "$name: thumb actual width check for $size" );
$this->assertEquals( $info['height'], $gis[1], "$name: thumb actual height check for $size" );
} else {
$this->assertEquals( $out[0], $gis[0], "$name: thumb actual width check for $size" );
$this->assertEquals( $out[1], $gis[1], "$name: thumb actual height check for $size" );
}
}
}
public static function provideFiles() {
return [
[
'landscape-plain.jpg',
'image/jpeg',
[
'width' => 160,
'height' => 120,
],
[
'80x60px' => [ 80, 60 ],
'9999x80px' => [ 107, 80 ],
'80px' => [ 80, 60 ],
'60px' => [ 60, 45 ],
]
],
[
'portrait-rotated.jpg',
'image/jpeg',
[
'width' => 120, // as rotated
'height' => 160, // as rotated
],
[
'80x60px' => [ 45, 60 ],
'9999x80px' => [ 60, 80 ],
'80px' => [ 80, 107 ],
'60px' => [ 60, 80 ],
]
]
];
}
/**
* Same as before, but with auto-rotation disabled.
* @dataProvider provideFilesNoAutoRotate
*/
public function testMetadataNoAutoRotate( $name, $type, $info ) {
$this->overrideConfigValue( MainConfigNames::EnableAutoRotation, false );
$file = $this->dataFile( $name, $type );
$this->assertEquals( $info['width'], $file->getWidth(), "$name: width check" );
$this->assertEquals( $info['height'], $file->getHeight(), "$name: height check" );
}
/**
* Same as before, but with auto-rotation set to auto and an image scaler that doesn't support it.
* @dataProvider provideFilesNoAutoRotate
*/
public function testMetadataAutoRotateUnsupported( $name, $type, $info ) {
$this->overrideConfigValues( [
MainConfigNames::EnableAutoRotation => null,
MainConfigNames::UseImageResize => false,
] );
$file = $this->dataFile( $name, $type );
$this->assertEquals( $info['width'], $file->getWidth(), "$name: width check" );
$this->assertEquals( $info['height'], $file->getHeight(), "$name: height check" );
}
/**
* @dataProvider provideFilesNoAutoRotate
*/
public function testRotationRenderingNoAutoRotate( $name, $type, $info, $thumbs ) {
$this->overrideConfigValue( MainConfigNames::EnableAutoRotation, false );
foreach ( $thumbs as $size => $out ) {
if ( preg_match( '/^(\d+)px$/', $size, $matches ) ) {
$params = [
'width' => $matches[1],
];
} elseif ( preg_match( '/^(\d+)x(\d+)px$/', $size, $matches ) ) {
$params = [
'width' => $matches[1],
'height' => $matches[2]
];
} else {
throw new InvalidArgumentException( 'bogus test data format ' . $size );
}
$file = $this->dataFile( $name, $type );
$thumb = $file->transform( $params, File::RENDER_NOW | File::RENDER_FORCE );
if ( $thumb->isError() ) {
/** @var MediaTransformError $thumb */
$this->fail( $thumb->toText() );
}
$this->assertEquals(
$out[0],
$thumb->getWidth(),
"$name: thumb reported width check for $size"
);
$this->assertEquals(
$out[1],
$thumb->getHeight(),
"$name: thumb reported height check for $size"
);
$gis = getimagesize( $thumb->getLocalCopyPath() );
if ( $out[0] > $info['width'] ) {
// Physical image won't be scaled bigger than the original.
$this->assertEquals( $info['width'], $gis[0], "$name: thumb actual width check for $size" );
$this->assertEquals( $info['height'], $gis[1], "$name: thumb actual height check for $size" );
} else {
$this->assertEquals( $out[0], $gis[0], "$name: thumb actual width check for $size" );
$this->assertEquals( $out[1], $gis[1], "$name: thumb actual height check for $size" );
}
}
}
public static function provideFilesNoAutoRotate() {
return [
[
'landscape-plain.jpg',
'image/jpeg',
[
'width' => 160,
'height' => 120,
],
[
'80x60px' => [ 80, 60 ],
'9999x80px' => [ 107, 80 ],
'80px' => [ 80, 60 ],
'60px' => [ 60, 45 ],
]
],
[
'portrait-rotated.jpg',
'image/jpeg',
[
'width' => 160, // since not rotated
'height' => 120, // since not rotated
],
[
'80x60px' => [ 80, 60 ],
'9999x80px' => [ 107, 80 ],
'80px' => [ 80, 60 ],
'60px' => [ 60, 45 ],
]
]
];
}
private const TEST_WIDTH = 100;
private const TEST_HEIGHT = 200;
/**
* @dataProvider provideBitmapExtractPreRotationDimensions
*/
public function testBitmapExtractPreRotationDimensions( $rotation, $expected ) {
$result = $this->handler->extractPreRotationDimensions( [
'physicalWidth' => self::TEST_WIDTH,
'physicalHeight' => self::TEST_HEIGHT,
], $rotation );
$this->assertEquals( $expected, $result );
}
public static function provideBitmapExtractPreRotationDimensions() {
return [
[
0,
[ self::TEST_WIDTH, self::TEST_HEIGHT ]
],
[
90,
[ self::TEST_HEIGHT, self::TEST_WIDTH ]
],
[
180,
[ self::TEST_WIDTH, self::TEST_HEIGHT ]
],
[
270,
[ self::TEST_HEIGHT, self::TEST_WIDTH ]
],
];
}
}
PK ! media/BmpHandlerTest.phpnu Iw handler = new BmpHandler();
$this->tempFile = $this->createMock( File::class );
}
/**
* @covers \BmpHandler::mustRender
*/
public function testMustRender() {
$this->assertTrue( $this->handler->mustRender( $this->tempFile ) );
}
/**
* @covers \BmpHandler::getThumbType
*/
public function testGetThumbType() {
$this->assertEquals( [ 'png', 'image/png' ], $this->handler->getThumbType( 'bmp', 'image/bmp' ) );
}
/**
* @covers \BmpHandler::getSizeAndMetadata
* @dataProvider provideGetSizeAndMetadata
*/
public function testGetSizeAndMetadata( string $filename, array $expected ) {
$stateMock = $this->createMock( MediaHandlerState::class );
$res = $this->handler->getSizeAndMetadata( $stateMock, $filename );
$this->assertEquals( $expected, $res );
}
public static function provideGetSizeAndMetadata(): array {
return [
[ __DIR__ . '/../../data/media/bmp-100x100.bmp', [ 'width' => 100, 'height' => 100 ] ],
[ __DIR__ . '/../../data/media/bmp-200x150.bmp', [ 'width' => 200, 'height' => 150 ] ],
[ __DIR__ . '/../../data/media/bmp-300x200.bmp', [ 'width' => 300, 'height' => 200 ] ],
];
}
}
PK ! x)7 )7 media/SvgHandlerTest.phpnu Iw filePath = __DIR__ . '/../../data/media/';
$this->overrideConfigValue( MainConfigNames::ShowEXIF, true );
$file = $this->dataFile( $filename, 'image/svg+xml' );
$handler = new SvgHandler();
$res = $handler->getCommonMetaArray( $file );
self::assertEquals( $expected, $res );
}
public static function provideGetIndependentMetaArray() {
return [
[ 'Tux.svg', [
'ObjectName' => 'Tux',
'ImageDescription' =>
'For more information see: http://commons.wikimedia.org/wiki/Image:Tux.svg',
] ],
[ 'Wikimedia-logo.svg', [] ]
];
}
/**
* @covers \SvgHandler::getMatchedLanguage()
* @dataProvider provideGetMatchedLanguage
*
* @param string $userPreferredLanguage
* @param array $svgLanguages
* @param string $expectedMatch
*/
public function testGetMatchedLanguage( $userPreferredLanguage, $svgLanguages, $expectedMatch ) {
$handler = new SvgHandler();
$match = $handler->getMatchedLanguage( $userPreferredLanguage, $svgLanguages );
self::assertEquals( $expectedMatch, $match );
}
public static function provideGetMatchedLanguage() {
return [
'no match' => [
'userPreferredLanguage' => 'en',
'svgLanguages' => [ 'de-DE', 'zh', 'ga', 'fr', 'sr-Latn-ME' ],
'expectedMatch' => null,
],
'no subtags' => [
'userPreferredLanguage' => 'en',
'svgLanguages' => [ 'de', 'zh', 'en', 'fr' ],
'expectedMatch' => 'en',
],
'user no subtags, svg 1 subtag' => [
'userPreferredLanguage' => 'en',
'svgLanguages' => [ 'de-DE', 'en-GB', 'en-US', 'fr' ],
'expectedMatch' => 'en-GB',
],
'user no subtags, svg >1 subtag' => [
'userPreferredLanguage' => 'sr',
'svgLanguages' => [ 'de-DE', 'sr-Cyrl-BA', 'sr-Latn-ME', 'en-US', 'fr' ],
'expectedMatch' => 'sr-Cyrl-BA',
],
'user 1 subtag, svg no subtags' => [
'userPreferredLanguage' => 'en-US',
'svgLanguages' => [ 'de', 'en', 'en', 'fr' ],
'expectedMatch' => null,
],
'user 1 subtag, svg 1 subtag' => [
'userPreferredLanguage' => 'en-US',
'svgLanguages' => [ 'de-DE', 'en-GB', 'en-US', 'fr' ],
'expectedMatch' => 'en-US',
],
'user 1 subtag, svg >1 subtag' => [
'userPreferredLanguage' => 'sr-Latn',
'svgLanguages' => [ 'de-DE', 'sr-Cyrl-BA', 'sr-Latn-ME', 'fr' ],
'expectedMatch' => 'sr-Latn-ME',
],
'user >1 subtag, svg >1 subtag' => [
'userPreferredLanguage' => 'sr-Latn-ME',
'svgLanguages' => [ 'de-DE', 'sr-Cyrl-BA', 'sr-Latn-ME', 'en-US', 'fr' ],
'expectedMatch' => 'sr-Latn-ME',
],
'user >1 subtag, svg <=1 subtag' => [
'userPreferredLanguage' => 'sr-Latn-ME',
'svgLanguages' => [ 'de-DE', 'sr-Cyrl', 'sr-Latn', 'en-US', 'fr' ],
'expectedMatch' => null,
],
'ensure case-insensitive' => [
'userPreferredLanguage' => 'sr-latn',
'svgLanguages' => [ 'de-DE', 'sr-Cyrl', 'sr-Latn-ME', 'en-US', 'fr' ],
'expectedMatch' => 'sr-Latn-ME',
],
'deprecated MW code als' => [
'userPreferredLanguage' => 'als',
'svgLanguages' => [ 'en', 'als', 'gsw' ],
'expectedMatch' => 'als',
],
'deprecated language code i-klingon' => [
'userPreferredLanguage' => 'i-klingon',
'svgLanguages' => [ 'i-klingon' ],
'expectedMatch' => 'i-klingon',
],
'complex IETF language code' => [
'userPreferredLanguage' => 'he',
'svgLanguages' => [ 'he-IL-u-ca-hebrew-tz-jeruslm' ],
'expectedMatch' => 'he-IL-u-ca-hebrew-tz-jeruslm',
],
];
}
/**
* @covers \SvgHandler::makeParamString()
* @dataProvider provideMakeParamString
*
* @param array $params
* @param string $expected
* @param string $message
*/
public function testMakeParamString( array $params, $expected, $message = '' ) {
$handler = new SvgHandler();
self::assertEquals( $expected, $handler->makeParamString( $params ), $message );
}
public static function provideMakeParamString() {
return [
[
[],
false,
"Don't thumbnail without knowing width"
],
[
[ 'lang' => 'ru' ],
false,
"Don't thumbnail without knowing width, even with lang"
],
[
[ 'width' => 123, ],
'123px',
'Width in thumb'
],
[
[ 'width' => 123, 'lang' => 'en' ],
'123px',
'Ignore lang=en'
],
[
[ 'width' => 123, 'targetlang' => 'en' ],
'123px',
'Ignore targetlang=en'
],
[
[ 'width' => 123, 'lang' => 'en', 'targetlang' => 'ru' ],
'123px',
"lang should override targetlang even if it's in English"
],
[
[ 'width' => 123, 'targetlang' => 'en' ],
'123px',
'Ignore targetlang=en'
],
[
[ 'width' => 123, 'lang' => 'en', 'targetlang' => 'en' ],
'123px',
'Ignore lang=targetlang=en'
],
[
[ 'width' => 123, 'lang' => 'ru' ],
'langru-123px',
'Include lang in thumb'
],
[
[ 'width' => 123, 'lang' => 'zh-Hans' ],
'langzh-hans-123px',
'Lowercase language codes',
],
[
[ 'width' => 123, 'targetlang' => 'ru' ],
'langru-123px',
'Include targetlang in thumb'
],
[
[ 'width' => 123, 'lang' => 'fr', 'targetlang' => 'sq' ],
'langfr-123px',
'lang should override targetlang'
],
];
}
/**
* @covers \SvgHandler::normaliseParamsInternal()
* @dataProvider provideNormaliseParamsInternal
*/
public function testNormaliseParamsInternal( $message,
$width,
$height,
array $params,
?array $paramsExpected = null
) {
$this->overrideConfigValue( MainConfigNames::SVGMaxSize, 1000 );
/** @var SvgHandler $handler */
$handler = TestingAccessWrapper::newFromObject( new SvgHandler() );
$file = $this->getMockBuilder( File::class )
->disableOriginalConstructor()
->onlyMethods( [ 'getWidth', 'getHeight', 'getMetadataArray', 'getHandler' ] )
->getMock();
$file->method( 'getWidth' )
->willReturn( $width );
$file->method( 'getHeight' )
->willReturn( $height );
$file->method( 'getMetadataArray' )
->willReturn( [
'version' => SvgHandler::SVG_METADATA_VERSION,
'translations' => [
'en' => SVGReader::LANG_FULL_MATCH,
'ru' => SVGReader::LANG_FULL_MATCH,
],
] );
$file->method( 'getHandler' )
->willReturn( $handler );
/** @var File $file */
$params = $handler->normaliseParamsInternal( $file, $params );
self::assertEquals( $paramsExpected, $params, $message );
}
public static function provideNormaliseParamsInternal() {
return [
[
'No need to change anything',
400, 500,
[ 'physicalWidth' => 400, 'physicalHeight' => 500 ],
[ 'physicalWidth' => 400, 'physicalHeight' => 500 ],
],
[
'Resize horizontal image',
2000, 1600,
[ 'physicalWidth' => 2000, 'physicalHeight' => 1600, 'page' => 0 ],
[ 'physicalWidth' => 1250, 'physicalHeight' => 1000, 'page' => 0 ],
],
[
'Resize vertical image',
1600, 2000,
[ 'physicalWidth' => 1600, 'physicalHeight' => 2000, 'page' => 0 ],
[ 'physicalWidth' => 1000, 'physicalHeight' => 1250, 'page' => 0 ],
],
[
'Preserve targetlang present in the image',
400, 500,
[ 'physicalWidth' => 400, 'physicalHeight' => 500, 'targetlang' => 'en' ],
[ 'physicalWidth' => 400, 'physicalHeight' => 500, 'targetlang' => 'en' ],
],
[
'Preserve targetlang present in the image 2',
400, 500,
[ 'physicalWidth' => 400, 'physicalHeight' => 500, 'targetlang' => 'en' ],
[ 'physicalWidth' => 400, 'physicalHeight' => 500, 'targetlang' => 'en' ],
],
[
'Remove targetlang not present in the image',
400, 500,
[ 'physicalWidth' => 400, 'physicalHeight' => 500, 'targetlang' => 'de' ],
[ 'physicalWidth' => 400, 'physicalHeight' => 500 ],
],
[
'Remove targetlang not present in the image 2',
400, 500,
[ 'physicalWidth' => 400, 'physicalHeight' => 500, 'targetlang' => 'ru-UA' ],
[ 'physicalWidth' => 400, 'physicalHeight' => 500 ],
],
];
}
/**
* @covers \SvgHandler::isEnabled()
* @dataProvider provideIsEnabled
*
* @param string $converter
* @param bool $expected
*/
public function testIsEnabled( $converter, $expected ) {
$this->overrideConfigValues( [
MainConfigNames::SVGConverter => $converter,
MainConfigNames::SVGNativeRendering => false,
] );
$handler = new SvgHandler();
self::assertEquals( $expected, $handler->isEnabled() );
}
public static function provideIsEnabled() {
return [
[ 'ImageMagick', true ],
[ 'sodipodi', true ],
[ 'invalid', false ],
];
}
/**
* @covers \SvgHandler::getAvailableLanguages()
* @dataProvider provideAvailableLanguages
*/
public function testGetAvailableLanguages( array $metadata, array $expected ) {
$metadata['version'] = SvgHandler::SVG_METADATA_VERSION;
$file = $this->getMockBuilder( File::class )
->disableOriginalConstructor()
->onlyMethods( [ 'getMetadataArray' ] )
->getMock();
$file->method( 'getMetadataArray' )
->willReturn( $metadata );
$handler = new SvgHandler();
/** @var File $file */
self::assertEquals( $expected, $handler->getAvailableLanguages( $file ) );
}
public static function provideAvailableLanguages() {
return [
[ [], [] ],
[ [ 'translations' => [] ], [] ],
[
[
'translations' => [
'ru-RU' => SVGReader::LANG_PREFIX_MATCH
]
],
[],
],
[
[
'translations' => [
'en' => SVGReader::LANG_FULL_MATCH,
'ru-RU' => SVGReader::LANG_PREFIX_MATCH,
'ru' => SVGReader::LANG_FULL_MATCH,
'fr-CA' => SVGReader::LANG_PREFIX_MATCH,
'zh-Hans' => SVGReader::LANG_FULL_MATCH,
'zh-Hans-TW' => SVGReader::LANG_FULL_MATCH,
'he-IL-u-ca-hebrew-tz-jeruslm' => SVGReader::LANG_FULL_MATCH,
],
],
[ 'en', 'ru', 'zh-hans', 'zh-hans-tw', 'he-il-u-ca-hebrew-tz-jeruslm' ],
],
];
}
/**
* @covers \SvgHandler::getLanguageFromParams()
* @dataProvider provideGetLanguageFromParams
*
* @param array $params
* @param string $expected
* @param string $message
*/
public function testGetLanguageFromParams( array $params, $expected, $message ) {
/** @var SvgHandler $handler */
$handler = TestingAccessWrapper::newFromObject( new SvgHandler() );
self::assertEquals( $expected, $handler->getLanguageFromParams( $params ), $message );
}
public static function provideGetLanguageFromParams() {
return [
[ [], 'en', 'Default no language to en' ],
[ [ 'preserve' => 'this' ], 'en', 'Default no language to en 2' ],
[ [ 'preserve' => 'this', 'lang' => 'ru' ], 'ru', 'Language from lang' ],
[ [ 'lang' => 'ru' ], 'ru', 'Language from lang 2' ],
[ [ 'targetlang' => 'fr' ], 'fr', 'Language from targetlang' ],
[ [ 'lang' => 'fr', 'targetlang' => 'de' ], 'fr', 'lang overrides targetlang' ],
];
}
/**
* @covers \SvgHandler::parseParamString()
* @dataProvider provideParseParamString
*
* @param string $paramString
* @param array $expected
* @param string $message
* @return void
*/
public function testParseParamString( string $paramString, $expected, $message ) {
/** @var SvgHandler $handler */
$handler = TestingAccessWrapper::newFromObject( new SvgHandler() );
$params = $handler->parseParamString( $paramString );
self::assertSame( $expected, $params, $message );
if ( $params === false ) {
return;
}
foreach ( $expected as $key => $value ) {
self::assertArrayHasKey( $key, $params, $message );
self::assertEquals( $value, $params[$key], $message );
}
}
public static function provideParseParamString() {
return [
[ '100px', [ 'width' => '100', 'lang' => 'en' ], 'Only width' ],
[ 'langde-100px', [ 'width' => '100', 'lang' => 'de' ], 'German language and width' ],
[ 'langzh-hans-100px', [ 'width' => '100', 'lang' => 'zh-hans' ], 'Chinese language and width' ],
[ 'langzh-Hans-100px', false, 'Capitalized language code' ],
[ 'langzh-TW-100px', false, 'Deprecated MW language code' ],
[ 'langund-100px', [ 'width' => '100', 'lang' => 'und' ], 'Undetermined language code' ],
[ 'langzh-%25-100px', false, 'Invalid IETF language code' ],
[ 'langhe-il-u-ca-hebrew-tz-jeruslm-100px',
[ 'width' => '100', 'lang' => 'he-il-u-ca-hebrew-tz-jeruslm' ],
'Very complex IETF language code'
],
];
}
/**
* @covers \SvgHandler::allowRenderingByUserAgent()
* @dataProvider provideNativeSVGDataRendering
*
* @param string $filename of the file to test
* @param bool $svgEnabled value of MainConfigNames::SVGNativeRendering
* @param int $filesizeLimit value of MainConfigNames::SVGNativeRenderingSizeLimit
* @param bool $expected if the SVG is expected to be rendered natively by browser agent
* @return void
*/
public function testNativeSVGDataRendering( $filename, $svgEnabled, $filesizeLimit, $expected ) {
$this->filePath = __DIR__ . '/../../data/media/';
$this->overrideConfigValues( [
MainConfigNames::SVGNativeRendering => $svgEnabled,
MainConfigNames::SVGNativeRenderingSizeLimit => $filesizeLimit,
] );
$file = $this->dataFile( $filename, 'image/svg+xml' );
$handler = new SvgHandler();
self::assertEquals( $expected, $handler->allowRenderingByUserAgent( $file ) );
}
public static function provideNativeSVGDataRendering() {
return [
[ 'Tux.svg', false, 50 * 1024, false, 'SVG without Native rendering enabled' ],
[ 'Tux.svg', true, 50 * 1024, true, 'SVG with Native rendering enforced' ],
[ 'Tux.svg', true, 1, true, 'SVG with Native rendering enforced ignoring filesize limit' ],
[ 'Tux.svg', 'partial', 223250, true, 'SVG with partial Native rendering' ],
[ 'Tux.svg', 'partial', 1, false, 'SVG with partial Native rendering, where filesize is bigger than the limit' ],
[ 'translated.svg', 'partial', null, false, 'SVG with translations should not be left to native rendering' ],
];
}
}
PK ! AJ} } " media/PNGMetadataExtractorTest.phpnu Iw assertArrayHasKey( 'text', $meta );
$meta = $meta['text'];
$this->assertArrayHasKey( 'Make', $meta );
$this->assertArrayHasKey( 'x-default', $meta['Make'] );
$this->assertEquals( $expected, $meta['Make']['x-default'] );
}
/**
* Test tEXt tag (Uncompressed textual metadata)
*/
public function testPngNativeText() {
$meta = PNGMetadataExtractor::getMetadata( self::FILE_PATH .
'Png-native-test.png' );
$expected = "Some long image desc";
$this->assertArrayHasKey( 'text', $meta );
$meta = $meta['text'];
$this->assertArrayHasKey( 'ImageDescription', $meta );
$this->assertArrayHasKey( 'x-default', $meta['ImageDescription'] );
$this->assertArrayHasKey( '_type', $meta['ImageDescription'] );
$this->assertEquals( $expected, $meta['ImageDescription']['x-default'] );
}
/**
* tEXt tags must be encoded iso-8859-1 (vs iTXt which are utf-8)
* Make sure non-ascii characters get converted properly
*/
public function testPngNativeTextNonAscii() {
$meta = PNGMetadataExtractor::getMetadata( self::FILE_PATH .
'Png-native-test.png' );
// Note the Copyright symbol here is a utf-8 one
// (aka \xC2\xA9) where in the file its iso-8859-1
// encoded as just \xA9.
$expected = "© 2010 Bawolff";
$this->assertArrayHasKey( 'text', $meta );
$meta = $meta['text'];
$this->assertArrayHasKey( 'Copyright', $meta );
$this->assertArrayHasKey( 'x-default', $meta['Copyright'] );
$this->assertEquals( $expected, $meta['Copyright']['x-default'] );
}
/**
* Given a normal static PNG, check the animation metadata returned.
*/
public function testStaticPngAnimationMetadata() {
$meta = PNGMetadataExtractor::getMetadata( self::FILE_PATH .
'Png-native-test.png' );
$this->assertSame( 0, $meta['frameCount'] );
$this->assertSame( 1, $meta['loopCount'] );
$this->assertSame( 0.0, $meta['duration'] );
}
/**
* Given an animated APNG image file
* check it gets animated metadata right.
*/
public function testApngAnimationMetadata() {
$meta = PNGMetadataExtractor::getMetadata( self::FILE_PATH .
'Animated_PNG_example_bouncing_beach_ball.png' );
$this->assertEquals( 20, $meta['frameCount'] );
// Note loop count of 0 = infinity
$this->assertSame( 0, $meta['loopCount'] );
$this->assertEqualsWithDelta( 1.5, $meta['duration'], 0.00001, '' );
}
public function testPngBitDepth8() {
$meta = PNGMetadataExtractor::getMetadata( self::FILE_PATH .
'Png-native-test.png' );
$this->assertEquals( 8, $meta['bitDepth'] );
}
public function testPngBitDepth1() {
$meta = PNGMetadataExtractor::getMetadata( self::FILE_PATH .
'1bit-png.png' );
$this->assertSame( 1, $meta['bitDepth'] );
}
public function testPngIndexColour() {
$meta = PNGMetadataExtractor::getMetadata( self::FILE_PATH .
'Png-native-test.png' );
$this->assertEquals( 'index-coloured', $meta['colorType'] );
}
public function testPngRgbColour() {
$meta = PNGMetadataExtractor::getMetadata( self::FILE_PATH .
'rgb-png.png' );
$this->assertEquals( 'truecolour-alpha', $meta['colorType'] );
}
public function testPngRgbNoAlphaColour() {
$meta = PNGMetadataExtractor::getMetadata( self::FILE_PATH .
'rgb-na-png.png' );
$this->assertEquals( 'truecolour', $meta['colorType'] );
}
public function testPngGreyscaleColour() {
$meta = PNGMetadataExtractor::getMetadata( self::FILE_PATH .
'greyscale-png.png' );
$this->assertEquals( 'greyscale-alpha', $meta['colorType'] );
}
public function testPngGreyscaleNoAlphaColour() {
$meta = PNGMetadataExtractor::getMetadata( self::FILE_PATH .
'greyscale-na-png.png' );
$this->assertEquals( 'greyscale', $meta['colorType'] );
}
/**
* T286273 -- tEXt chunk replaced by null bytes
*/
public function testPngInvalidChunk() {
$meta = PNGMetadataExtractor::getMetadata( self::FILE_PATH .
'tEXt-invalid-masked.png' );
$this->assertEquals( 10, $meta['width'] );
$this->assertEquals( 10, $meta['height'] );
}
/**
* T286273 -- oversize chunk
*/
public function testPngOversizeChunk() {
// Write a temporary file consisting of a normal PNG plus an extra tEXt chunk.
// Try to hold the chunk in memory only once.
$path = $this->getNewTempFile();
copy( self::FILE_PATH . '1bit-png.png', $path );
$chunkTypeAndData = "tEXtkey\0value" . str_repeat( '.', 10000000 );
$crc = crc32( $chunkTypeAndData );
$chunkLength = strlen( $chunkTypeAndData ) - 4;
$file = fopen( $path, 'r+' );
fseek( $file, -12, SEEK_END );
$iend = fread( $file, 12 );
fseek( $file, -12, SEEK_END );
fwrite( $file, pack( 'N', $chunkLength ) );
fwrite( $file, $chunkTypeAndData );
fwrite( $file, pack( 'N', $crc ) );
fwrite( $file, $iend );
fclose( $file );
// Extract the metadata
$meta = PNGMetadataExtractor::getMetadata( $path );
$this->assertEquals( 50, $meta['width'] );
$this->assertEquals( 50, $meta['height'] );
// Verify that the big chunk didn't end up in the metadata
$this->assertLessThan( 100000, strlen( serialize( $meta ) ) );
}
}
PK ! + = media/Jpeg2000HandlerTest.phpnu Iw assertEquals( $expectedResult, $handler->getSizeAndMetadata(
new TrivialMediaHandlerState, $path ) );
}
public static function provideTestGetSizeAndMetadata() {
return [
[ __DIR__ . '/../../data/media/jpeg2000-lossless.jp2', [
'width' => 100,
'height' => 100,
'bits' => 8,
] ],
[ __DIR__ . '/../../data/media/jpeg2000-lossy.jp2', [
'width' => 100,
'height' => 100,
'bits' => 8,
] ],
[ __DIR__ . '/../../data/media/jpeg2000-alpha.jp2', [
'width' => 100,
'height' => 100,
'bits' => 8,
] ],
[ __DIR__ . '/../../data/media/jpeg2000-profile.jpf', [
'width' => 100,
'height' => 100,
'bits' => 8,
] ],
// Error cases
[ __FILE__, [] ],
];
}
}
PK ! (d media/SVGReaderTest.phpnu Iw assertMetadata( $infile, $expected );
}
/**
* @dataProvider provideSvgFilesWithXMLMetadata
*/
public function testGetXMLMetadata( $infile, $expected ) {
$r = new XMLReader();
$this->assertMetadata( $infile, $expected );
}
/**
* @dataProvider provideSvgUnits
*/
public function testScaleSVGUnit( $inUnit, $expected ) {
$this->assertEquals(
$expected,
SVGReader::scaleSVGUnit( $inUnit ),
'SVG unit conversion and scaling failure'
);
}
private function assertMetadata( $infile, $expected ) {
if ( $expected === false ) {
$this->expectException( InvalidSVGException::class );
}
$svgReader = new SVGReader( $infile );
$data = $svgReader->getMetadata();
$this->assertEquals( $expected, $data, 'SVG metadata extraction test' );
}
public static function provideSvgFiles() {
$base = __DIR__ . '/../../data/media';
return [
[
"$base/Wikimedia-logo.svg",
[
'width' => 1024,
'height' => 1024,
'originalWidth' => '1024',
'originalHeight' => '1024',
'translations' => [],
]
],
[
"$base/QA_icon.svg",
[
'width' => 60,
'height' => 60,
'originalWidth' => '60',
'originalHeight' => '60',
'translations' => [],
]
],
[
"$base/Gtk-media-play-ltr.svg",
[
'width' => 60,
'height' => 60,
'originalWidth' => '60.0000000',
'originalHeight' => '60.0000000',
'translations' => [],
]
],
[
"$base/Toll_Texas_1.svg",
// This file triggered T33719, needs entity expansion in the xmlns checks
[
'width' => 385,
'height' => 385,
'originalWidth' => '385',
'originalHeight' => '385.0004883',
'translations' => [],
]
],
[
"$base/Tux.svg",
[
'width' => 512,
'height' => 594,
'originalWidth' => '100%',
'originalHeight' => '100%',
'title' => 'Tux',
'translations' => [],
'description' => 'For more information see: http://commons.wikimedia.org/wiki/Image:Tux.svg',
]
],
[
"$base/Speech_bubbles.svg",
[
'width' => 669,
'height' => 491,
'originalWidth' => '17.7cm',
'originalHeight' => '13cm',
'translations' => [
'de' => SVGReader::LANG_FULL_MATCH,
'fr' => SVGReader::LANG_FULL_MATCH,
'nl' => SVGReader::LANG_FULL_MATCH,
'tlh-ca' => SVGReader::LANG_FULL_MATCH,
'tlh' => SVGReader::LANG_PREFIX_MATCH
],
]
],
[
"$base/Soccer_ball_animated.svg",
[
'width' => 150,
'height' => 150,
'originalWidth' => '150',
'originalHeight' => '150',
'animated' => true,
'translations' => []
],
],
[
"$base/comma_separated_viewbox.svg",
[
'width' => 512,
'height' => 594,
'originalWidth' => '100%',
'originalHeight' => '100%',
'translations' => []
],
],
[
"$base/css-animated.svg",
[
'width' => 100,
'height' => 100,
'originalWidth' => '100',
'originalHeight' => '100',
'animated' => true,
'translations' => []
],
],
];
}
public static function provideSvgFilesWithXMLMetadata() {
$base = __DIR__ . '/../../data/media';
$metadata = '
image/svg+xml
';
// phpcs:enable
$metadata = str_replace( "\r", '', $metadata ); // Windows compat
return [
[
"$base/US_states_by_total_state_tax_revenue.svg",
[
'height' => 593,
'metadata' => $metadata,
'width' => 959,
'originalWidth' => '958.69',
'originalHeight' => '592.78998',
'translations' => [],
]
],
];
}
public static function provideSvgUnits() {
return [
[ '1', 1 ],
[ '1.1', 1.1 ],
[ '0.1', 0.1 ],
[ '.1', 0.1 ],
[ '1e2', 100 ],
[ '1E2', 100 ],
[ '+1', 1 ],
[ '-1', -1 ],
[ '-1.1', -1.1 ],
[ '1e+2', 100 ],
[ '1e-2', 0.01 ],
[ '10px', 10 ],
[ '10.2cm', 10.2 * 37.795275 ],
[ '10pt', 10 * 1.333333 ],
[ '10pc', 10 * 16 ],
[ '10mm', 10 * 3.7795275 ],
[ '10q', 10 * 0.944881 ],
[ '10Q', 10 * 0.944881 ],
[ '10cm', 10 * 37.795275 ],
[ '10in', 10 * 96 ],
[ '10em', 10 * 16 ],
[ '10rem', 10 * 16 ],
[ '10ex', 10 * 8 ],
[ '10ch', 10 * 8 ],
[ '10%', 51.2 ],
[ '10 px', 10 ],
// Invalid values
[ '1e1.1', 10 ],
[ '10bp', 10 ],
[ 'p10', null ],
];
}
}
PK ! A A media/ThumbnailImageTest.phpnu Iw dataFile( $name );
}
private function newThumbnail( $file = null, $url = null, $path = false, $parameters = [] ) {
$file ??= $this->newFile();
$path ??= 'thumb/a/ab/Test.jpg/123px-Test.jpg';
$url ??= "https://example.com/w/images/$path";
$parameters += [
'width' => 200,
'height' => 100,
];
return new ThumbnailImage( $file, $url, $path, $parameters );
}
public function testConstructor() {
$file = $this->newFile();
$path = 'thumb/a/ab/Test.jpg/123px-Test.jpg';
$url = "https://example.com/w/images/$path";
$parameters = [
'width' => 300,
'height' => 200,
];
$thumbnail = $this->newThumbnail(
$file,
$url,
$path,
$parameters
);
$this->assertSame( $file, $thumbnail->getFile() );
$this->assertSame( $url, $thumbnail->getUrl() );
$this->assertSame( $parameters['width'], $thumbnail->getWidth() );
$this->assertSame( $parameters['height'], $thumbnail->getHeight() );
$this->assertFalse( $thumbnail->isError() );
}
/**
* Check that we can stream data from a file system path
*/
public function testStreamFileWithStatus_fsPath() {
$fsPath = $this->getFilePath() . 'test.jpg';
$data = file_get_contents( $fsPath );
$file = $this->newFile();
// NOTE: We need the FileRepo in $file for the streamer option,
// to prevent a real reset of the output buffer.
$thumbnail = $this->newThumbnail( $file, null, $fsPath );
ob_start();
$thumbnail->streamFileWithStatus();
$output = ob_get_clean();
$this->assertSame( $data, $output );
}
/**
* Check that we can stream using the FileBackend
*/
public function testStreamFileWithStatus_thumbStoragePath() {
$this->backend = $this->createNoOpMock( FileBackend::class, [ 'streamFile' ] );
$this->backend->expects( $this->once() )
->method( 'streamFile' )
->wilLreturn( StatusValue::newGood() );
$this->repo = new FileRepo( $this->getRepoOptions() );
$file = $this->newFile( 'test.jpg' );
$thumbnail = $this->newThumbnail(
$file,
$file->getThumbUrl(),
$file->getThumbPath()
);
$thumbnail->streamFileWithStatus();
// no assertion needed, we just expect streamFile() to be called.
}
/**
* Check that we don't explode if no file repo is known
*/
public function testStreamFileWithStatus_UnregisteredLocalFile() {
// Use a non-existing file, so streaming will fail.
// If streaming was successful, we'd generate real output, since
// without a file backend, we have no way to disable a full reset
// of output buffers.
$fsPath = $this->getFilePath() . 'this does not exist';
// No file repo or backend!
$file = new UnregisteredLocalFile( false, false, $fsPath );
$thumbnail = $this->newThumbnail( $file );
// Check that streaming fails gracefully
$status = $thumbnail->streamFileWithStatus();
$this->assertStatusError( 'backend-fail-stream', $status );
}
}
PK ! _) 4 watchlist/WatchedItemQueryServiceIntegrationTest.phpnu Iw overrideConfigValue( MainConfigNames::WatchlistExpiry, true );
}
public function testGetWatchedItemsForUser(): void {
$store = $this->getServiceContainer()->getWatchedItemStore();
$queryService = $this->getServiceContainer()->getWatchedItemQueryService();
$user = self::getTestUser()->getUser();
$initialCount = count( $store->getWatchedItemsForUser( $user ) );
// Add two watched items, one of which is already expired, and check that only 1 is returned.
$store->addWatch(
$user,
new TitleValue( 0, __METHOD__ . ' no expiry 1' )
);
$store->addWatch(
$user,
new TitleValue( 0, __METHOD__ . ' expired a week ago or in a week' ),
'1 week ago'
);
$result1 = $queryService->getWatchedItemsForUser( $user );
$this->assertCount( $initialCount + 1, $result1, "User ID: " . $user->getId() );
// Add another of each type of item, and make sure the new results are as expected.
$store->addWatch(
$user,
new TitleValue( 0, __METHOD__ . ' no expiry 2' )
);
$store->addWatch(
$user,
new TitleValue( 0, __METHOD__ . ' expired a week ago 2' ),
'1 week ago'
);
$result2 = $queryService->getWatchedItemsForUser( $user );
$this->assertCount( $initialCount + 2, $result2 );
// Make one of the expired items permanent, and check again.
$store->addWatch(
$user,
new TitleValue( 0, __METHOD__ . ' expired a week ago 2' ),
'infinity'
);
$result3 = $queryService->getWatchedItemsForUser( $user );
$this->assertCount( $initialCount + 3, $result3 );
// Make the other expired item expire in a week's time, and make sure it appears in the list.
$store->addWatch(
$user,
new TitleValue( 0, __METHOD__ . ' expired a week ago or in a week' ),
'1 week'
);
$result4 = $queryService->getWatchedItemsForUser( $user );
$this->assertCount( $initialCount + 4, $result4 );
}
public function testGetWatchedItemsForUserWithExpiriesDisabled() {
$this->overrideConfigValue( MainConfigNames::WatchlistExpiry, false );
$store = $this->getServiceContainer()->getWatchedItemStore();
$queryService = $this->getServiceContainer()->getWatchedItemQueryService();
$user = self::getTestUser()->getUser();
$initialCount = count( $store->getWatchedItemsForUser( $user ) );
$store->addWatch( $user, new TitleValue( 0, __METHOD__ ), '1 week ago' );
$result = $queryService->getWatchedItemsForUser( $user );
$this->assertCount( $initialCount + 1, $result );
}
public function testGetWatchedItemsWithRecentChangeInfo_watchlistExpiry(): void {
$store = $this->getServiceContainer()->getWatchedItemStore();
$queryService = $this->getServiceContainer()->getWatchedItemQueryService();
$user = self::getTestUser()->getUser();
$options = [];
$startFrom = null;
$initialCount = count( $queryService->getWatchedItemsWithRecentChangeInfo( $user,
$options, $startFrom ) );
// Add two watched items, one of which is already expired, and check that only 1 is returned.
$userEditTarget1 = new TitleValue( 0, __METHOD__ . ' no expiry 1' );
$this->editPage( $userEditTarget1, 'First revision' );
$store->addWatch(
$user,
$userEditTarget1
);
$userEditTarget2 = new TitleValue( 0, __METHOD__ . ' expired a week ago or in a week' );
$this->editPage( $userEditTarget2, 'First revision' );
$store->addWatch(
$user,
$userEditTarget2,
'1 week ago'
);
$result1 = $queryService->getWatchedItemsWithRecentChangeInfo( $user, $options, $startFrom );
$this->assertCount( $initialCount + 1, $result1 );
// Add another of each type of item, and make sure the new results are as expected.
$userEditTarget3 = new TitleValue( 0, __METHOD__ . ' no expiry 2' );
$this->editPage( $userEditTarget3, 'First revision' );
$store->addWatch(
$user,
$userEditTarget3
);
$userEditTarget4 = new TitleValue( 0, __METHOD__ . ' expired a week ago 2' );
$this->editPage( $userEditTarget4, 'First revision' );
$store->addWatch(
$user,
$userEditTarget4,
'1 week ago'
);
$result2 = $queryService->getWatchedItemsWithRecentChangeInfo( $user );
$this->assertCount( $initialCount + 2, $result2 );
// Make one of the expired items permanent, and check again.
$store->addWatch(
$user,
$userEditTarget4,
'infinity'
);
$result3 = $queryService->getWatchedItemsWithRecentChangeInfo( $user );
$this->assertCount( $initialCount + 3, $result3 );
// Make the other expired item expire in a week's time, and make sure it appears in the list.
$store->addWatch(
$user,
$userEditTarget2,
'1 week'
);
$result4 = $queryService->getWatchedItemsWithRecentChangeInfo( $user );
$this->assertCount( $initialCount + 4, $result4 );
}
public static function invalidWatchlistTokenProvider() {
return [
[ 'wrongToken' ],
[ '' ],
];
}
/**
* @dataProvider invalidWatchlistTokenProvider
*/
public function testGetWatchedItemsWithRecentChangeInfo_watchlistOwnerAndInvalidToken( $token ) {
// Moved from the Unit test because the ApiUsageException call creates a Message object
// and down the line needs MediaWikiServices
$user = $this->createNoOpMock(
User::class,
[ 'isRegistered', 'getId', 'useRCPatrol' ]
);
$user->method( 'isRegistered' )->willReturn( true );
$user->method( 'getId' )->willReturn( 1 );
$user->method( 'useRCPatrol' )->willReturn( true );
$otherUser = $this->createNoOpMock(
User::class,
[ 'isRegistered', 'getId', 'useRCPatrol' ]
);
$otherUser->method( 'isRegistered' )->willReturn( true );
$otherUser->method( 'getId' )->willReturn( 2 );
$otherUser->method( 'useRCPatrol' )->willReturn( true );
$userOptionsLookup = $this->createMock( UserOptionsLookup::class );
$userOptionsLookup->expects( $this->once() )
->method( 'getOption' )
->with( $otherUser, 'watchlisttoken' )
->willReturn( '0123456789abcdef' );
$this->setService( 'UserOptionsLookup', $userOptionsLookup );
$queryService = $this->getServiceContainer()->getWatchedItemQueryService();
$this->expectException( ApiUsageException::class );
$this->expectExceptionMessage( 'Incorrect watchlist token provided' );
$queryService->getWatchedItemsWithRecentChangeInfo(
$user,
[ 'watchlistOwner' => $otherUser, 'watchlistOwnerToken' => $token ]
);
}
}
PK ! jAB AB - watchlist/WatchedItemStoreIntegrationTest.phpnu Iw overrideConfigValues( [
MainConfigNames::WatchlistExpiry => true,
MainConfigNames::WatchlistExpiryMaxDuration => '6 months',
] );
}
private function getUser(): UserIdentity {
return new UserIdentityValue( 42, 'WatchedItemStoreIntegrationTestUser' );
}
public function testWatchAndUnWatchItem() {
$user = $this->getUser();
$title = Title::makeTitle( NS_MAIN, 'WatchedItemStoreIntegrationTestPage' );
$store = $this->getServiceContainer()->getWatchedItemStore();
// Cleanup after previous tests
$store->removeWatch( $user, $title );
$initialWatchers = $store->countWatchers( $title );
$initialUserWatchedItems = $store->countWatchedItems( $user );
$this->assertFalse(
$store->isWatched( $user, $title ),
'Page should not initially be watched'
);
$this->assertFalse( $store->isTempWatched( $user, $title ) );
$store->addWatch( $user, $title );
$this->assertTrue(
$store->isWatched( $user, $title ),
'Page should be watched'
);
$this->assertFalse(
$store->isTempWatched( $user, $title ),
'Page should not be temporarily watched'
);
$this->assertEquals( $initialUserWatchedItems + 1, $store->countWatchedItems( $user ) );
$watchedItemsForUser = $store->getWatchedItemsForUser( $user );
$this->assertCount( $initialUserWatchedItems + 1, $watchedItemsForUser );
$watchedItemsForUserHasExpectedItem = false;
foreach ( $watchedItemsForUser as $watchedItem ) {
if (
$watchedItem->getUserIdentity()->equals( $user ) &&
$watchedItem->getTarget() == $title->getTitleValue()
) {
$watchedItemsForUserHasExpectedItem = true;
}
}
$this->assertTrue(
$watchedItemsForUserHasExpectedItem,
'getWatchedItemsForUser should contain the page'
);
$this->assertEquals( $initialWatchers + 1, $store->countWatchers( $title ) );
$this->assertEquals(
$initialWatchers + 1,
$store->countWatchersMultiple( [ $title ] )[$title->getNamespace()][$title->getDBkey()]
);
$this->assertEquals(
[ 0 => [ 'WatchedItemStoreIntegrationTestPage' => $initialWatchers + 1 ] ],
$store->countWatchersMultiple( [ $title ], [ 'minimumWatchers' => $initialWatchers + 1 ] )
);
$this->assertEquals(
[ 0 => [ 'WatchedItemStoreIntegrationTestPage' => 0 ] ],
$store->countWatchersMultiple( [ $title ], [ 'minimumWatchers' => $initialWatchers + 2 ] )
);
$this->assertEquals(
[ $title->getNamespace() => [ $title->getDBkey() => null ] ],
$store->getNotificationTimestampsBatch( $user, [ $title ] )
);
$store->removeWatch( $user, $title );
$this->assertFalse(
$store->isWatched( $user, $title ),
'Page should be unwatched'
);
$this->assertEquals( $initialUserWatchedItems, $store->countWatchedItems( $user ) );
$watchedItemsForUser = $store->getWatchedItemsForUser( $user );
$this->assertCount( $initialUserWatchedItems, $watchedItemsForUser );
$watchedItemsForUserHasExpectedItem = false;
foreach ( $watchedItemsForUser as $watchedItem ) {
if (
$watchedItem->getUserIdentity()->equals( $user ) &&
$watchedItem->getTarget() == $title->getTitleValue()
) {
$watchedItemsForUserHasExpectedItem = true;
}
}
$this->assertFalse(
$watchedItemsForUserHasExpectedItem,
'getWatchedItemsForUser should not contain the page'
);
$this->assertEquals( $initialWatchers, $store->countWatchers( $title ) );
$this->assertEquals(
$initialWatchers,
$store->countWatchersMultiple( [ $title ] )[$title->getNamespace()][$title->getDBkey()]
);
$this->assertEquals(
[ $title->getNamespace() => [ $title->getDBkey() => false ] ],
$store->getNotificationTimestampsBatch( $user, [ $title ] )
);
}
public function testWatchAndUnWatchItemWithExpiry(): void {
$user = $this->getUser();
$title = Title::makeTitle( NS_MAIN, 'WatchedItemStoreIntegrationTestPage' );
$store = $this->getServiceContainer()->getWatchedItemStore();
$initialUserWatchedItems = $store->countWatchedItems( $user );
// Watch for a duration greater than the max ($wgWatchlistExpiryMaxDuration),
// which should get changed to the max.
$expiry = wfTimestamp( TS_MW, strtotime( '10 years' ) );
$store->addWatch( $user, $title, $expiry );
$this->assertLessThanOrEqual(
wfTimestamp( TS_MW, strtotime( '6 months' ) ),
$store->loadWatchedItem( $user, $title )->getExpiry()
);
// Valid expiry that's less than the max.
$expiry = wfTimestamp( TS_MW, strtotime( '1 week' ) );
$store->addWatch( $user, $title, $expiry );
$this->assertSame(
$expiry,
$store->loadWatchedItem( $user, $title )->getExpiry()
);
$this->assertEquals( $initialUserWatchedItems + 1, $store->countWatchedItems( $user ) );
$this->assertTrue( $store->isTempWatched( $user, $title ) );
// Invalid expiry, nothing should change.
$exceptionThrown = false;
try {
$store->addWatch( $user, $title, 'invalid expiry' );
} catch ( InvalidArgumentException $exception ) {
$exceptionThrown = true;
// Asserting watchedItem getExpiry stays unchanged
$this->assertSame(
$expiry,
$store->loadWatchedItem( $user, $title )->getExpiry()
);
$this->assertSame(
$initialUserWatchedItems + 1,
$store->countWatchedItems( $user )
);
}
$this->assertTrue( $exceptionThrown );
// Changed to infinity, so expiry row should be removed.
$store->addWatch( $user, $title, 'infinity' );
$this->assertNull(
$store->loadWatchedItem( $user, $title )->getExpiry()
);
$this->assertEquals( $initialUserWatchedItems + 1, $store->countWatchedItems( $user ) );
$this->assertFalse( $store->isTempWatched( $user, $title ) );
// Updating to a valid expiry.
$store->addWatch( $user, $title, '1 month' );
$this->assertLessThanOrEqual(
strtotime( '1 month' ),
wfTimestamp(
TS_UNIX,
$store->loadWatchedItem( $user, $title )->getExpiry()
)
);
$this->assertEquals( $initialUserWatchedItems + 1, $store->countWatchedItems( $user ) );
// Expiry in the past, should not be considered watched.
$store->addWatch( $user, $title, '20090101000000' );
$this->assertEquals( $initialUserWatchedItems, $store->countWatchedItems( $user ) );
// Test isWatch(), which would normally pull from the cache. In this case
// the cache should bust and return false since the item has expired.
$this->assertFalse( $store->isWatched( $user, $title ) );
$this->assertFalse( $store->isTempWatched( $user, $title ) );
}
public function testWatchAndUnwatchMultipleWithExpiry(): void {
$user = $this->getUser();
$title1 = Title::makeTitle( NS_MAIN, 'WatchedItemStoreIntegrationTestPage1' );
$title2 = Title::makeTitle( NS_MAIN, 'WatchedItemStoreIntegrationTestPage1' );
$store = $this->getServiceContainer()->getWatchedItemStore();
// Use a relative timestamp in the near future to ensure we don't exceed the max.
// See testWatchAndUnWatchItemWithExpiry() for tests regarding the max duration.
$timestamp = wfTimestamp( TS_MW, strtotime( '1 week' ) );
$store->addWatchBatchForUser( $user, [ $title1, $title2 ], $timestamp );
$this->assertSame(
$timestamp,
$store->loadWatchedItem( $user, $title1 )->getExpiry()
);
$this->assertSame(
$timestamp,
$store->loadWatchedItem( $user, $title2 )->getExpiry()
);
// Clear expiries.
$store->addWatchBatchForUser( $user, [ $title1, $title2 ], 'infinity' );
$this->assertNull(
$store->loadWatchedItem( $user, $title1 )->getExpiry()
);
$this->assertNull(
$store->loadWatchedItem( $user, $title2 )->getExpiry()
);
}
public function testWatchBatchAndClearItems() {
$user = $this->getUser();
$title1 = Title::makeTitle( NS_MAIN, 'WatchedItemStoreIntegrationTestPage1' );
$title2 = Title::makeTitle( NS_MAIN, 'WatchedItemStoreIntegrationTestPage2' );
$store = $this->getServiceContainer()->getWatchedItemStore();
$store->addWatchBatchForUser( $user, [ $title1, $title2 ] );
$this->assertTrue( $store->isWatched( $user, $title1 ) );
$this->assertTrue( $store->isWatched( $user, $title2 ) );
$store->clearUserWatchedItems( $user );
$this->assertFalse( $store->isWatched( $user, $title1 ) );
$this->assertFalse( $store->isWatched( $user, $title2 ) );
}
public function testUpdateResetAndSetNotificationTimestamp() {
$user = $this->getUser();
$otherUser = new UserIdentityValue(
$user->getId() + 1,
$user->getName() . '_other'
);
$title = Title::makeTitle( NS_MAIN, 'WatchedItemStoreIntegrationTestPage' );
$store = $this->getServiceContainer()->getWatchedItemStore();
$store->addWatch( $user, $title );
$this->assertNull( $store->loadWatchedItem( $user, $title )->getNotificationTimestamp() );
$initialVisitingWatchers = $store->countVisitingWatchers( $title, '20150202020202' );
$initialUnreadNotifications = $store->countUnreadNotifications( $user );
$store->updateNotificationTimestamp( $otherUser, $title, '20150202010101' );
$this->assertSame(
'20150202010101',
$store->loadWatchedItem( $user, $title )->getNotificationTimestamp()
);
$this->assertEquals(
[ $title->getNamespace() => [ $title->getDBkey() => '20150202010101' ] ],
$store->getNotificationTimestampsBatch( $user, [ $title ] )
);
$this->assertEquals(
$initialVisitingWatchers - 1,
$store->countVisitingWatchers( $title, '20150202020202' )
);
$this->assertEquals(
$initialVisitingWatchers - 1,
$store->countVisitingWatchersMultiple(
[ [ $title, '20150202020202' ] ]
)[$title->getNamespace()][$title->getDBkey()]
);
$this->assertEquals(
$initialUnreadNotifications + 1,
$store->countUnreadNotifications( $user )
);
$this->assertSame(
true,
$store->countUnreadNotifications( $user, $initialUnreadNotifications + 1 )
);
$this->assertTrue( $store->resetNotificationTimestamp( $user, $title ) );
$this->assertNull( $store->getWatchedItem( $user, $title )->getNotificationTimestamp() );
$this->assertEquals(
[ $title->getNamespace() => [ $title->getDBkey() => null ] ],
$store->getNotificationTimestampsBatch( $user, [ $title ] )
);
// Run the job queue
$this->runJobs();
$this->assertEquals(
$initialVisitingWatchers,
$store->countVisitingWatchers( $title, '20150202020202' )
);
$this->assertEquals(
$initialVisitingWatchers,
$store->countVisitingWatchersMultiple(
[ [ $title, '20150202020202' ] ]
)[$title->getNamespace()][$title->getDBkey()]
);
$this->assertEquals(
[ 0 => [ 'WatchedItemStoreIntegrationTestPage' => $initialVisitingWatchers ] ],
$store->countVisitingWatchersMultiple(
[ [ $title, '20150202020202' ] ], $initialVisitingWatchers
)
);
$this->assertEquals(
[ 0 => [ 'WatchedItemStoreIntegrationTestPage' => 0 ] ],
$store->countVisitingWatchersMultiple(
[ [ $title, '20150202020202' ] ], $initialVisitingWatchers + 1
)
);
// setNotificationTimestampsForUser specifying a title
$this->assertTrue(
$store->setNotificationTimestampsForUser( $user, '20100202020202', [ $title ] )
);
$this->assertSame(
'20100202020202',
$store->getWatchedItem( $user, $title )->getNotificationTimestamp()
);
// setNotificationTimestampsForUser not specifying a title
// This will try to use a DeferredUpdate; disable that
$mockCallback = static function ( $callback ) {
$callback();
};
$scopedOverride = $store->overrideDeferredUpdatesAddCallableUpdateCallback( $mockCallback );
$this->assertTrue(
$store->setNotificationTimestampsForUser( $user, '20110202020202' )
);
// Because the operation above is normally deferred, it doesn't clear the cache
// Clear the cache manually
$wrappedStore = TestingAccessWrapper::newFromObject( $store );
$wrappedStore->uncacheUser( $user );
$this->assertSame(
'20110202020202',
$store->getWatchedItem( $user, $title )->getNotificationTimestamp()
);
}
public function testDuplicateAllAssociatedEntries() {
// Fake current time to be 2020-05-27T00:00:00Z
ConvertibleTimestamp::setFakeTime( '20200527000000' );
$user = $this->getUser();
$titleOld = Title::makeTitle( NS_MAIN, 'WatchedItemStoreIntegrationTestPageOld' );
$titleNew = Title::makeTitle( NS_MAIN, 'WatchedItemStoreIntegrationTestPageNew' );
$store = $this->getServiceContainer()->getWatchedItemStore();
$store->addWatch( $user, $titleOld->getSubjectPage(), '99990123000000' );
$store->addWatch( $user, $titleOld->getTalkPage(), '99990123000000' );
// Fetch stored expiry (may have changed due to wgWatchlistExpiryMaxDuration).
// Note we use loadWatchedItem() instead of getWatchedItem() to bypass the process cache.
$expectedExpiry = $store->loadWatchedItem( $user, $titleOld )->getExpiry();
// Watch the new title with a different expiry, so that we can confirm
// it gets replaced with the old title's expiry.
$store->addWatch( $user, $titleNew->getSubjectPage(), '1 day' );
$store->addWatch( $user, $titleNew->getTalkPage(), '1 day' );
// Use the sysop test user as well on the old title, so we can test that
// each user's respective expiry is correctly copied.
$user2 = $this->getTestSysop()->getUser();
$store->addWatch( $user2, $titleOld->getSubjectPage(), '1 week' );
$store->addWatch( $user2, $titleOld->getTalkPage(), '1 week' );
$expectedExpiry2 = $store->loadWatchedItem( $user2, $titleOld )->getExpiry();
// Duplicate associated entries. This will try to use a DeferredUpdate; disable that.
$mockCallback = static function ( $callback ) {
$callback();
};
$store->overrideDeferredUpdatesAddCallableUpdateCallback( $mockCallback );
$store->duplicateAllAssociatedEntries( $titleOld, $titleNew );
$this->assertTrue( $store->isWatched( $user, $titleOld->getSubjectPage() ) );
$this->assertTrue( $store->isWatched( $user, $titleOld->getTalkPage() ) );
$this->assertTrue( $store->isWatched( $user, $titleNew->getSubjectPage() ) );
$this->assertTrue( $store->isWatched( $user, $titleNew->getTalkPage() ) );
$oldExpiry = $store->loadWatchedItem( $user, $titleOld )->getExpiry();
$newExpiry = $store->loadWatchedItem( $user, $titleNew )->getExpiry();
$this->assertSame( $expectedExpiry, $oldExpiry );
$this->assertSame( $expectedExpiry, $newExpiry );
// Same for $user2 and $expectedExpiry2
$oldExpiry = $store->loadWatchedItem( $user2, $titleOld )->getExpiry();
$newExpiry = $store->loadWatchedItem( $user2, $titleNew )->getExpiry();
$this->assertSame( $expectedExpiry2, $oldExpiry );
$this->assertSame( $expectedExpiry2, $newExpiry );
}
public function testRemoveExpired() {
$store = $this->getServiceContainer()->getWatchedItemStore();
// Clear out any expired rows, to start from a known point.
$store->removeExpired( 10 );
$this->assertSame( 0, $store->countExpired() );
// Add three pages, two of which have already expired.
$user = $this->getUser();
$store->addWatch( $user, Title::makeTitle( NS_MAIN, 'P1' ), '2020-01-25' );
$store->addWatch( $user, Title::makeTitle( NS_MAIN, 'P2' ), '20200101000000' );
$store->addWatch( $user, Title::makeTitle( NS_MAIN, 'P3' ), '1 month' );
// Test that they can be counted and removed correctly.
$this->assertSame( 2, $store->countExpired() );
$store->removeExpired( 1 );
$this->assertSame( 1, $store->countExpired() );
}
public function testRemoveOrphanedExpired() {
$store = $this->getServiceContainer()->getWatchedItemStore();
// Clear out any expired rows, to start from a known point.
$store->removeExpired( 10 );
// Manually insert some orphaned non-expired rows.
$orphanRows = [
[ 'we_item' => '100000', 'we_expiry' => $this->getDb()->timestamp( '30300101000000' ) ],
[ 'we_item' => '100001', 'we_expiry' => $this->getDb()->timestamp( '30300101000000' ) ],
];
$this->getDb()->newInsertQueryBuilder()
->insertInto( 'watchlist_expiry' )
->rows( $orphanRows )
->caller( __METHOD__ )
->execute();
$initialRowCount = $this->getDb()->newSelectQueryBuilder()
->select( '*' )
->from( 'watchlist_expiry' )
->caller( __METHOD__ )->fetchRowCount();
// Make sure the orphans aren't removed if it's not requested.
$store->removeExpired( 10, false );
$this->assertSame(
$initialRowCount,
$this->getDb()->newSelectQueryBuilder()
->select( '*' )
->from( 'watchlist_expiry' )
->caller( __METHOD__ )->fetchRowCount()
);
// Make sure they are removed when requested.
$store->removeExpired( 10, true );
$this->assertSame(
$initialRowCount - 2,
$this->getDb()->newSelectQueryBuilder()
->select( '*' )
->from( 'watchlist_expiry' )
->caller( __METHOD__ )->fetchRowCount()
);
}
}
PK ! > ' watchlist/ClearUserWatchlistJobTest.phpnu Iw getServiceContainer()->getWatchedItemStore();
}
public function testRun() {
$user = $this->getUser();
$watchedItemStore = $this->getWatchedItemStore();
$watchedItemStore->addWatch( $user, new TitleValue( 0, 'A' ) );
$watchedItemStore->addWatch( $user, new TitleValue( 1, 'A' ) );
$watchedItemStore->addWatch( $user, new TitleValue( 0, 'B' ) );
$watchedItemStore->addWatch( $user, new TitleValue( 1, 'B' ) );
$maxId = $watchedItemStore->getMaxId();
$watchedItemStore->addWatch( $user, new TitleValue( 0, 'C' ) );
$watchedItemStore->addWatch( $user, new TitleValue( 1, 'C' ) );
$this->overrideConfigValue( MainConfigNames::UpdateRowsPerQuery, 2 );
$jobQueueGroup = $this->getServiceContainer()->getJobQueueGroup();
$jobQueueGroup->push(
new ClearUserWatchlistJob( [
'userId' => $user->getId(), 'maxWatchlistId' => $maxId,
] )
);
$this->assertSame( 1, $jobQueueGroup->getQueueSizes()['clearUserWatchlist'] );
$this->assertEquals( 6, $watchedItemStore->countWatchedItems( $user ) );
$this->runJobs( [ 'complete' => false ], [ 'maxJobs' => 1 ] );
$this->assertSame( 1, $jobQueueGroup->getQueueSizes()['clearUserWatchlist'] );
$this->assertEquals( 4, $watchedItemStore->countWatchedItems( $user ) );
$this->runJobs( [ 'complete' => false ], [ 'maxJobs' => 1 ] );
$this->assertSame( 1, $jobQueueGroup->getQueueSizes()['clearUserWatchlist'] );
$this->assertEquals( 2, $watchedItemStore->countWatchedItems( $user ) );
$this->runJobs( [ 'complete' => false ], [ 'maxJobs' => 1 ] );
$this->assertSame( 0, $jobQueueGroup->getQueueSizes()['clearUserWatchlist'] );
$this->assertEquals( 2, $watchedItemStore->countWatchedItems( $user ) );
$this->assertTrue( $watchedItemStore->isWatched( $user, new TitleValue( 0, 'C' ) ) );
$this->assertTrue( $watchedItemStore->isWatched( $user, new TitleValue( 1, 'C' ) ) );
}
public function testRunWithWatchlistExpiry() {
// Set up.
$this->overrideConfigValue( MainConfigNames::WatchlistExpiry, true );
$user = $this->getUser();
$watchedItemStore = $this->getWatchedItemStore();
// Add two watched items, one with an expiry.
$watchedItemStore->addWatch( $user, new TitleValue( 0, __METHOD__ . 'no expiry' ) );
$watchedItemStore->addWatch( $user, new TitleValue( 0, __METHOD__ . 'has expiry' ), '1 week' );
// Get the IDs of these items.
$itemIds = $this->getDb()->newSelectQueryBuilder()
->select( 'wl_id' )
->from( 'watchlist' )
->where( [ 'wl_user' => $user->getId() ] )
->caller( __METHOD__ )->fetchFieldValues();
// Clear the watchlist by running the job.
$job = new ClearUserWatchlistJob( [
'userId' => $user->getId(),
'maxWatchlistId' => max( $itemIds ),
] );
$this->getServiceContainer()->getJobQueueGroup()->push( $job );
$this->runJobs( [ 'complete' => false ], [ 'maxJobs' => 1 ] );
// Confirm that there are now no expiry records.
$watchedCount = $this->getDb()->newSelectQueryBuilder()
->select( '*' )
->from( 'watchlist_expiry' )
->where( [ 'we_item' => $itemIds ] )
->caller( __METHOD__ )->fetchRowCount();
$this->assertSame( 0, $watchedCount );
}
}
PK ! |A| | search/SearchHighlighterTest.phpnu Iw highlightSimple( $wikiText, [ $searchTerm ], 1, $contextChars );
$this->assertEquals( $expectedOutput, $actual );
}
public static function provideHighlightSimple() {
return [
'no match' => [
'this is a very simple text.',
'cannotmatch',
'',
10
],
'match a single word at the end of the string' => [
'this is a very simple text.',
'text',
"this is a very simple text.\n",
40
],
'utf-8 sequences should not be broken' => [
"text with long trailing UTF-8 sequences: " . str_repeat( "\u{1780}", 6 ) . ".",
'text',
"text with long trailing UTF-8 sequences: " . str_repeat( "\u{1780}", 5 ) . "\n",
41
],
];
}
}
PK ! P 9 9 . search/ParserOutputSearchDataExtractorTest.phpnu Iw 'Bar',
'New_page' => ''
];
$parserOutput = new ParserOutput( '', [], $categories );
$searchDataExtractor = new ParserOutputSearchDataExtractor();
$this->assertEquals(
[ 'Foo bar', 'New page' ],
$searchDataExtractor->getCategories( $parserOutput )
);
}
public function testGetExternalLinks() {
$parserOutput = new ParserOutput();
$parserOutput->addExternalLink( 'https://foo' );
$parserOutput->addExternalLink( 'https://bar' );
$searchDataExtractor = new ParserOutputSearchDataExtractor();
$this->assertEquals(
[ 'https://foo', 'https://bar' ],
$searchDataExtractor->getExternalLinks( $parserOutput )
);
}
public function testGetOutgoingLinks() {
$parserOutput = new ParserOutput();
$parserOutput->addLink( Title::makeTitle( NS_MAIN, 'Foo_bar' ), 1 );
$parserOutput->addLink( Title::makeTitle( NS_HELP, 'Contents' ), 2 );
$searchDataExtractor = new ParserOutputSearchDataExtractor();
// this indexes links with db key
$this->assertEquals(
[ 'Foo_bar', 'Help:Contents' ],
$searchDataExtractor->getOutgoingLinks( $parserOutput )
);
}
public function testGetTemplates() {
$title = Title::makeTitle( NS_TEMPLATE, 'Cite_news' );
$parserOutput = new ParserOutput();
$parserOutput->addTemplate( $title, 10, 100 );
$searchDataExtractor = new ParserOutputSearchDataExtractor();
$this->assertEquals(
[ 'Template:Cite news' ],
$searchDataExtractor->getTemplates( $parserOutput )
);
}
}
PK ! v search/SearchResultSetTest.phpnu Iw setService( 'RevisionLookup', $this->createMock( RevisionLookup::class ) );
}
/**
* @covers \SearchResultSet::getIterator
* @covers \BaseSearchResultSet::next
* @covers \BaseSearchResultSet::rewind
*/
public function testIterate() {
$title = Title::makeTitle( NS_MAIN, __METHOD__ );
$result = SearchResult::newFromTitle( $title );
$resultSet = new MockSearchResultSet( [ $result ] );
$this->assertSame( 1, $resultSet->numRows() );
$count = 0;
foreach ( $resultSet as $iterResult ) {
$this->assertEquals( $result, $iterResult );
$count++;
}
$this->assertSame( 1, $count );
$this->hideDeprecated( 'BaseSearchResultSet::rewind' );
$this->hideDeprecated( 'BaseSearchResultSet::next' );
$resultSet->rewind();
$count = 0;
foreach ( $resultSet as $iterResult ) {
$this->assertEquals( $result, $iterResult );
$count++;
}
$this->assertSame( 1, $count );
}
/**
* @covers \SearchResultSetTrait::augmentResult
* @covers \SearchResultSetTrait::setAugmentedData
*/
public function testDelayedResultAugment() {
$title = Title::makeTitle( NS_MAIN, __METHOD__ );
$title->resetArticleID( 42 );
$result = SearchResult::newFromTitle( $title );
$resultSet = new MockSearchResultSet( [ $result ] );
$resultSet->augmentResult( $result );
$this->assertEquals( [], $result->getExtensionData() );
$resultSet->setAugmentedData( 'foo', [
$result->getTitle()->getArticleID() => 'bar'
] );
$this->assertEquals( [ 'foo' => 'bar' ], $result->getExtensionData() );
}
/**
* @covers \SearchResultSet::shrink
* @covers \SearchResultSet::count
* @covers \SearchResultSet::hasMoreResults
*/
public function testHasMoreResults() {
$title = Title::makeTitle( NS_MAIN, __METHOD__ );
$result = SearchResult::newFromTitle( $title );
$resultSet = new MockSearchResultSet( array_fill( 0, 3, $result ) );
$this->assertCount( 3, $resultSet );
$this->assertFalse( $resultSet->hasMoreResults() );
$resultSet->shrink( 3 );
$this->assertFalse( $resultSet->hasMoreResults() );
$resultSet->shrink( 2 );
$this->assertTrue( $resultSet->hasMoreResults() );
}
/**
* @covers \SearchResultSet::shrink
*/
public function testShrink() {
$title = Title::makeTitle( NS_MAIN, __METHOD__ );
$results = array_fill( 0, 3, SearchResult::newFromTitle( $title ) );
$resultSet = new MockSearchResultSet( $results );
$this->assertCount( 3, $resultSet->extractResults() );
$this->assertCount( 3, $resultSet->extractTitles() );
$resultSet->shrink( 1 );
$this->assertCount( 1, $resultSet->extractResults() );
$this->assertCount( 1, $resultSet->extractTitles() );
}
}
PK ! 9`w ' search/SearchNearMatchResultSetTest.phpnu Iw assertSame( 0, $resultSet->numRows() );
$resultSet = new SearchNearMatchResultSet( Title::newMainPage() );
$this->assertSame( 1, $resultSet->numRows() );
}
}
PK ! \% % ! search/SearchEnginePrefixTest.phpnu Iw isWikitextNS( NS_MAIN ) ) {
// tests are skipped if NS_MAIN is not wikitext
return;
}
$this->insertPage( 'Sandbox' );
$this->insertPage( 'Bar' );
$this->insertPage( 'Example' );
$this->insertPage( 'Example Bar' );
$this->insertPage( 'Example Foo' );
$this->insertPage( 'Example Foo/Bar' );
$this->insertPage( 'Example/Baz' );
$this->insertPage( 'Sample' );
$this->insertPage( 'Sample Ban' );
$this->insertPage( 'Sample Eat' );
$this->insertPage( 'Sample Who' );
$this->insertPage( 'Sample Zoo' );
$this->insertPage( 'Redirect test', '#REDIRECT [[Redirect Test]]' );
$this->insertPage( 'Redirect Test' );
$this->insertPage( 'Redirect Test Worse Result' );
$this->insertPage( 'Redirect test2', '#REDIRECT [[Redirect Test2]]' );
$this->insertPage( 'Redirect TEST2', '#REDIRECT [[Redirect Test2]]' );
$this->insertPage( 'Redirect Test2' );
$this->insertPage( 'Redirect Test2 Worse Result' );
$this->insertPage( 'Talk:Sandbox' );
$this->insertPage( 'Talk:Example' );
$this->insertPage( 'User:Example' );
$this->insertPage( 'Barcelona' );
$this->insertPage( 'Barbara' );
$this->insertPage( 'External' );
}
protected function setUp(): void {
parent::setUp();
if ( !$this->isWikitextNS( NS_MAIN ) ) {
$this->markTestSkipped( 'Main namespace does not support wikitext.' );
}
// Avoid special pages from extensions interferring with the tests
$this->overrideConfigValues( [
MainConfigNames::SpecialPages => [],
MainConfigNames::Hooks => [],
] );
$this->search = $this->getServiceContainer()->newSearchEngine();
$this->search->setNamespaces( [] );
}
protected function searchProvision( ?array $results = null ) {
if ( $results === null ) {
$this->overrideConfigValue( MainConfigNames::Hooks, [] );
} else {
$this->setTemporaryHook(
'PrefixSearchBackend',
static function ( $namespaces, $search, $limit, &$srchres ) use ( $results ) {
$srchres = $results;
return false;
}
);
}
}
public static function provideSearch() {
return [
[ [
'Empty string',
'query' => '',
'results' => [],
] ],
[ [
'All invalid characters, effectively empty',
'query' => '[',
'results' => [],
] ],
[ [
'Main namespace with title prefix',
'query' => 'Sa',
'results' => [
'Sample',
'Sample Ban',
'Sample Eat',
],
// Third result when testing offset
'offsetresult' => [
'Sample Who',
],
] ],
[ [
'Some invalid characters',
'query' => '[[Sa]]',
'results' => [
'Sample',
'Sample Ban',
'Sample Eat',
],
'offsetresult' => [ 'Sample Who' ],
] ],
[ [
'Talk namespace prefix',
'query' => 'Talk:',
'results' => [
'Talk:Example',
'Talk:Sandbox',
],
] ],
[ [
'User namespace prefix',
'query' => 'User:',
'results' => [
'User:Example',
],
] ],
[ [
'Special namespace prefix',
'query' => 'Special:',
'results' => [
'Special:ActiveUsers',
'Special:AllMessages',
'Special:AllPages',
],
// Third result when testing offset
'offsetresult' => [
'Special:AncientPages',
],
] ],
[ [
'Special namespace with prefix',
'query' => 'Special:Un',
'results' => [
'Special:Unblock',
'Special:UncategorizedCategories',
'Special:UncategorizedFiles',
],
// Third result when testing offset
'offsetresult' => [
'Special:UncategorizedPages',
],
] ],
[ [
'Special page name',
'query' => 'Special:EditWatchlist',
'results' => [
],
] ],
[ [
'Special page subpages',
'query' => 'Special:EditWatchlist/',
'results' => [
'Special:EditWatchlist/clear',
'Special:EditWatchlist/raw',
],
] ],
[ [
'Special page subpages with prefix',
'query' => 'Special:EditWatchlist/cl',
'results' => [
'Special:EditWatchlist/clear',
],
] ],
];
}
/**
* @dataProvider provideSearch
* @covers \SearchEngine::defaultPrefixSearch
*/
public function testSearch( array $case ) {
$this->search->setLimitOffset( 3 );
$results = $this->search->defaultPrefixSearch( $case['query'] );
$results = array_map( static function ( Title $t ) {
return $t->getPrefixedText();
}, $results );
$this->assertEquals(
$case['results'],
$results,
$case[0]
);
}
/**
* @dataProvider provideSearch
* @covers \SearchEngine::defaultPrefixSearch
*/
public function testSearchWithOffset( array $case ) {
$this->search->setLimitOffset( 3, 1 );
$results = $this->search->defaultPrefixSearch( $case['query'] );
$results = array_map( static function ( Title $t ) {
return $t->getPrefixedText();
}, $results );
// We don't expect the first result when offsetting
array_shift( $case['results'] );
// And sometimes we expect a different last result
$expected = isset( $case['offsetresult'] ) ?
array_merge( $case['results'], $case['offsetresult'] ) :
$case['results'];
$this->assertEquals(
$expected,
$results,
$case[0]
);
}
public static function provideSearchBackend() {
return [
[ [
'Simple case',
'provision' => [
'Bar',
'Barcelona',
'Barbara',
],
'query' => 'Bar',
'results' => [
'Bar',
'Barcelona',
'Barbara',
],
] ],
[ [
'Exact match not in first result should be moved to the first result (T72958)',
'provision' => [
'Barcelona',
'Bar',
'Barbara',
],
'query' => 'Bar',
'results' => [
'Bar',
'Barcelona',
'Barbara',
],
] ],
[ [
'Exact match missing from results should be added as first result (T72958)',
'provision' => [
'Barcelona',
'Barbara',
'Bart',
],
'query' => 'Bar',
'results' => [
'Bar',
'Barcelona',
'Barbara',
],
] ],
[ [
'Exact match missing and not existing pages should be dropped',
'provision' => [
'Exile',
'Exist',
'External',
],
'query' => 'Ex',
'results' => [
'External',
],
] ],
[ [
"Exact match shouldn't override already found match if " .
"exact is redirect and found isn't",
'provision' => [
// Target of the exact match is low in the list
'Redirect Test Worse Result',
'Redirect Test',
],
'query' => 'redirect test',
'results' => [
// Redirect target is pulled up and exact match isn't added
'Redirect Test',
'Redirect Test Worse Result',
],
] ],
[ [
"Exact match should override already found match if " .
"both exact match and found match are redirect",
'provision' => [
// Another redirect to the same target as the exact match
// is low in the list
'Redirect Test2 Worse Result',
'Redirect test2',
],
'query' => 'redirect TEST2',
'results' => [
// Found redirect is pulled to the top and exact match isn't
// added
'Redirect TEST2',
'Redirect Test2 Worse Result',
],
] ],
[ [
"Exact match should override any already found matches that " .
"are redirects to it",
'provision' => [
// Another redirect to the same target as the exact match
// is low in the list
'Redirect Test Worse Result',
'Redirect test',
],
'query' => 'Redirect Test',
'results' => [
// Found redirect is pulled to the top and exact match isn't
// added
'Redirect Test',
'Redirect Test Worse Result',
'Redirect test',
],
] ],
[ [
"Extra results must not be returned",
'provision' => [
'Example',
'Example Bar',
'Example Foo',
'Example Foo/Bar'
],
'query' => 'foo',
'results' => [
'Example',
'Example Bar',
'Example Foo',
],
] ],
];
}
/**
* @dataProvider provideSearchBackend
* @covers \PrefixSearch::searchBackend
*/
public function testSearchBackend( array $case ) {
$search = $this->mockSearchWithResults( $case['provision'] );
$results = $search->completionSearch( $case['query'] );
$results = $results->map( static function ( SearchSuggestion $s ) {
return $s->getText();
} );
$this->assertEquals(
$case['results'],
$results,
$case[0]
);
}
public static function paginationProvider() {
$res = [ 'Example', 'Example Bar', 'Example Foo', 'Example Foo/Bar' ];
return [
'With less than requested results no pagination' => [
false, array_slice( $res, 0, 2 ),
],
'With same as requested results no pagination' => [
false, array_slice( $res, 0, 3 ),
],
'With extra result returned offer pagination' => [
true, $res,
],
];
}
/**
* @dataProvider paginationProvider
* @covers \SearchSuggestionSet::hasMoreResults
*/
public function testPagination( $hasMoreResults, $provision ) {
$search = $this->mockSearchWithResults( $provision );
$results = $search->completionSearch( 'irrelevant' );
$this->assertEquals( $hasMoreResults, $results->hasMoreResults() );
}
private function mockSearchWithResults( $titleStrings, $limit = 3 ) {
$search = $this->getMockBuilder( SearchEngine::class )
->onlyMethods( [ 'completionSearchBackend' ] )->getMock();
$return = SearchSuggestionSet::fromStrings( $titleStrings );
$search->method( 'completionSearchBackend' )
->willReturn( $return );
$search->setLimitOffset( $limit );
return $search;
}
}
PK ! 8! 8! search/PrefixSearchTest.phpnu Iw isWikitextNS( NS_MAIN ) ) {
// tests are skipped if NS_MAIN is not wikitext
return;
}
$this->insertPage( 'Sandbox' );
$this->insertPage( 'Bar' );
$this->insertPage( 'Example' );
$this->insertPage( 'Example Bar' );
$this->insertPage( 'Example Foo' );
$this->insertPage( 'Example Foo/Bar' );
$this->insertPage( 'Example/Baz' );
$this->insertPage( 'Redirect test', '#REDIRECT [[Redirect Test]]' );
$this->insertPage( 'Redirect Test' );
$this->insertPage( 'Redirect Test Worse Result' );
$this->insertPage( 'Redirect test2', '#REDIRECT [[Redirect Test2]]' );
$this->insertPage( 'Redirect TEST2', '#REDIRECT [[Redirect Test2]]' );
$this->insertPage( 'Redirect Test2' );
$this->insertPage( 'Redirect Test2 Worse Result' );
$this->insertPage( 'Talk:Sandbox' );
$this->insertPage( 'Talk:Example' );
$this->insertPage( 'User:Example' );
$this->overrideConfigValues( [
MainConfigNames::ExtraNamespaces => [ self::NS_NONCAP => 'NonCap' ],
MainConfigNames::CapitalLinkOverrides => [ self::NS_NONCAP => false ],
] );
$this->insertPage( Title::makeTitle( self::NS_NONCAP, 'Bar' ) );
$this->insertPage( Title::makeTitle( self::NS_NONCAP, 'Upper' ) );
$this->insertPage( Title::makeTitle( self::NS_NONCAP, 'sandbox' ) );
}
protected function setUp(): void {
parent::setUp();
if ( !$this->isWikitextNS( NS_MAIN ) ) {
$this->markTestSkipped( 'Main namespace does not support wikitext.' );
}
// Avoid special pages from extensions interfering with the tests
$this->overrideConfigValues( [
MainConfigNames::SpecialPages => [],
MainConfigNames::Hooks => [],
MainConfigNames::ExtraNamespaces => [ self::NS_NONCAP => 'NonCap' ],
MainConfigNames::CapitalLinkOverrides => [ self::NS_NONCAP => false ],
] );
}
protected function searchProvision( ?array $results = null ) {
if ( $results === null ) {
$this->overrideConfigValue( MainConfigNames::Hooks, [] );
} else {
$this->setTemporaryHook(
'PrefixSearchBackend',
static function ( $namespaces, $search, $limit, &$srchres ) use ( $results ) {
$srchres = $results;
return false;
}
);
}
}
public static function provideSearch() {
return [
[ [
'Empty string',
'query' => '',
'results' => [],
] ],
[ [
'Main namespace with title prefix',
'query' => 'Ex',
'results' => [
'Example',
'Example/Baz',
'Example Bar',
],
// Third result when testing offset
'offsetresult' => [
'Example Foo',
],
] ],
[ [
'Talk namespace prefix',
'query' => 'Talk:',
'results' => [
'Talk:Example',
'Talk:Sandbox',
],
] ],
[ [
'User namespace prefix',
'query' => 'User:',
'results' => [
'User:Example',
],
] ],
[ [
'Special namespace prefix',
'query' => 'Special:',
'results' => [
'Special:ActiveUsers',
'Special:AllMessages',
'Special:AllPages',
],
// Third result when testing offset
'offsetresult' => [
'Special:AncientPages',
],
] ],
[ [
'Special namespace with prefix',
'query' => 'Special:Un',
'results' => [
'Special:Unblock',
'Special:UncategorizedCategories',
'Special:UncategorizedFiles',
],
// Third result when testing offset
'offsetresult' => [
'Special:UncategorizedPages',
],
] ],
[ [
'Special page name',
'query' => 'Special:EditWatchlist',
'results' => [],
] ],
[ [
'Special page subpages',
'query' => 'Special:EditWatchlist/',
'results' => [
'Special:EditWatchlist/clear',
'Special:EditWatchlist/raw',
],
] ],
[ [
'Special page subpages with prefix',
'query' => 'Special:EditWatchlist/cl',
'results' => [
'Special:EditWatchlist/clear',
],
] ],
[ [
'Namespace with case sensitive first letter',
'query' => 'NonCap:upper',
'results' => []
] ],
[ [
'Multinamespace search',
'query' => 'B',
'results' => [
'Bar',
'NonCap:Bar',
],
'namespaces' => [ NS_MAIN, self::NS_NONCAP ],
] ],
[ [
'Multinamespace search with lowercase first letter',
'query' => 'sand',
'results' => [
'Sandbox',
'NonCap:sandbox',
],
'namespaces' => [ NS_MAIN, self::NS_NONCAP ],
] ],
];
}
/**
* @dataProvider provideSearch
* @covers \PrefixSearch::search
* @covers \PrefixSearch::searchBackend
*/
public function testSearch( array $case ) {
$this->searchProvision( null );
$namespaces = $case['namespaces'] ?? [];
$searcher = new StringPrefixSearch;
$results = $searcher->search( $case['query'], 3, $namespaces );
$this->assertEquals(
$case['results'],
$results,
$case[0]
);
}
/**
* @dataProvider provideSearch
* @covers \PrefixSearch::search
* @covers \PrefixSearch::searchBackend
*/
public function testSearchWithOffset( array $case ) {
$this->searchProvision( null );
$namespaces = $case['namespaces'] ?? [];
$searcher = new StringPrefixSearch;
$results = $searcher->search( $case['query'], 3, $namespaces, 1 );
// We don't expect the first result when offsetting
array_shift( $case['results'] );
// And sometimes we expect a different last result
$expected = isset( $case['offsetresult'] ) ?
array_merge( $case['results'], $case['offsetresult'] ) :
$case['results'];
$this->assertEquals(
$expected,
$results,
$case[0]
);
}
public static function provideSearchBackend() {
return [
[ [
'Simple case',
'provision' => [
'Bar',
'Barcelona',
'Barbara',
],
'query' => 'Bar',
'results' => [
'Bar',
'Barcelona',
'Barbara',
],
] ],
[ [
'Exact match not on top (T72958)',
'provision' => [
'Barcelona',
'Bar',
'Barbara',
],
'query' => 'Bar',
'results' => [
'Bar',
'Barcelona',
'Barbara',
],
] ],
[ [
'Exact match missing (T72958)',
'provision' => [
'Barcelona',
'Barbara',
'Bart',
],
'query' => 'Bar',
'results' => [
'Bar',
'Barcelona',
'Barbara',
],
] ],
[ [
'Exact match missing and not existing',
'provision' => [
'Exile',
'Exist',
'External',
],
'query' => 'Ex',
'results' => [
'Exile',
'Exist',
'External',
],
] ],
[ [
"Exact match shouldn't override already found match if " .
"exact is redirect and found isn't",
'provision' => [
// Target of the exact match is low in the list
'Redirect Test Worse Result',
'Redirect Test',
],
'query' => 'redirect test',
'results' => [
// Redirect target is pulled up and exact match isn't added
'Redirect Test',
'Redirect Test Worse Result',
],
] ],
[ [
"Exact match should override already found match if " .
"both exact match and found match are redirect",
'provision' => [
// Another redirect to the same target as the exact match
// is low in the list
'Redirect Test2 Worse Result',
'Redirect test2',
],
'query' => 'redirect TEST2',
'results' => [
// Found redirect is pulled to the top and exact match isn't
// added
'Redirect TEST2',
'Redirect Test2 Worse Result',
],
] ],
[ [
"Exact match should override any already found matches that " .
"are redirects to it",
'provision' => [
// Another redirect to the same target as the exact match
// is low in the list
'Redirect Test Worse Result',
'Redirect test',
],
'query' => 'Redirect Test',
'results' => [
// Found redirect is pulled to the top and exact match isn't
// added
'Redirect Test',
'Redirect Test Worse Result',
],
] ],
];
}
/**
* @dataProvider provideSearchBackend
* @covers \PrefixSearch::searchBackend
*/
public function testSearchBackend( array $case ) {
$this->filterDeprecated( '/Use of PrefixSearchBackend hook/' );
$this->searchProvision( $case['provision'] );
$searcher = new StringPrefixSearch;
$results = $searcher->search( $case['query'], 3 );
$this->assertEquals(
$case['results'],
$results,
$case[0]
);
}
}
PK ! Mq , search/SearchResultThumbnailProviderTest.phpnu Iw [
'id' => 1,
'text' => 'File_1.jpg',
'namespace' => NS_FILE,
],
'article_with_thumb' => [
'id' => 2,
'text' => 'Title_2',
'namespace' => NS_MAIN,
],
'article_without_thumb' => [
'id' => 3,
'text' => 'Title_3',
'namespace' => NS_MAIN,
],
];
/**
* Map of page id to thumbnail page id, both of which are expected to be present in self::TITLES.
* This map will be used to build a mock response for the SearchResultProvideThumbnail hook.
*/
protected const HOOK_PROVIDED_THUMBNAILS_BY_ID = [
self::TITLES['article_with_thumb']['id'] => self::TITLES['file']['id'],
];
/** @var SearchResultThumbnailProvider */
private $thumbnailProvider;
/** @var Title[] */
private $titles = [];
public static function articleThumbnailsProvider(): array {
return [
// assert that NS_FILE pages provide their own file
[
// page ids
[ self::TITLES['file']['id'] ],
// thumbnail ids
[ self::TITLES['file']['id'] ],
// size
500
],
// assert that hook provides thumbnails for non-file pages
[
[ self::TITLES['article_with_thumb']['id'] ],
[ self::TITLES['file']['id'] ],
500
],
// assert thumbnail is missing when not NS_FILE & hook doesn't provide
[
[ self::TITLES['article_without_thumb']['id'] ],
[],
500
],
// assert that size is optional and defaults to something functional
[
[ self::TITLES['file']['id'] ],
[ self::TITLES['file']['id'] ],
null
]
];
}
public function setUp(): void {
parent::setUp();
// build mock titles based on descriptions in self::TITLES
$this->titles = [];
foreach ( self::TITLES as $data ) {
$this->titles[$data['id']] = $this->makeMockTitle(
$data['text'],
[ 'id' => $data['id'], 'namespace' => $data['namespace'] ]
);
}
// compile a mock repo with all NS_FILE pages known in self::TITLES
$thumbnails = array_map(
static fn ( Title $title ) => $title->getDBkey(),
array_filter(
$this->titles,
static fn ( Title $title ) => $title->inNamespace( NS_FILE )
)
);
$mockRepoGroup = $this->makeMockRepoGroup( $thumbnails );
// create a hook that provides all thumbnails defined in HOOK_PROVIDED_THUMBNAILS_BY_ID
$hookContainer = $this->createHookContainer( [
'SearchResultProvideThumbnail' => function ( $pageIdentities, &$results, $size ) use ( $mockRepoGroup ) {
foreach ( self::HOOK_PROVIDED_THUMBNAILS_BY_ID as $pageId => $thumbnailPageId ) {
if ( !isset( $pageIdentities[$pageId] ) ) {
// skip this thumbnail, it was not requested
continue;
}
$articleTitle = $this->titles[$pageId];
if ( !$articleTitle ) {
throw new InvalidArgumentException(
'self::HOOK_PROVIDED_THUMBNAILS_BY_ID key references a page missing from in self::TITLES'
);
}
$thumbnailTitle = $this->titles[$thumbnailPageId];
if ( !$thumbnailTitle ) {
throw new InvalidArgumentException(
'self::HOOK_PROVIDED_THUMBNAILS_BY_ID value references a page missing from in self::TITLES'
);
}
$results[$pageId] = $this->thumbnailProvider->buildSearchResultThumbnailFromFile(
$mockRepoGroup->findFile( $thumbnailTitle ),
$size
);
}
},
] );
$this->thumbnailProvider = new SearchResultThumbnailProvider( $mockRepoGroup, $hookContainer );
}
/**
* @dataProvider articleThumbnailsProvider
* @covers \MediaWiki\Search\SearchResultThumbnailProvider::getThumbnails
* @covers \MediaWiki\Search\SearchResultThumbnailProvider::buildSearchResultThumbnailFromFile
* @param int[] $pageIds
* @param int[] $thumbnailIds
* @param int|null $size
*/
public function testGetThumbnails( array $pageIds, array $thumbnailIds, ?int $size = null ) {
$pageIdentities = array_intersect_key( $this->titles, array_fill_keys( $pageIds, null ) );
$thumbnails = $this->thumbnailProvider->getThumbnails( $pageIdentities, $size );
// confirm that titles for which there is no thumbnail are missing
$missingThumbnails = array_diff_key( $pageIdentities, $thumbnails );
foreach ( $missingThumbnails as $pageId => $pageIdentity ) {
$this->assertArrayNotHasKey( $pageId, $thumbnails );
}
foreach ( $thumbnails as $pageId => $thumbnail ) {
// confirm thumbnail matches what we expect
$expectedName = $this->titles[$pageId]->inNamespace( NS_FILE )
? $this->titles[$pageId]->getDBkey()
: $this->titles[self::HOOK_PROVIDED_THUMBNAILS_BY_ID[$pageId]]->getDBkey();
$this->assertEquals( $expectedName, $thumbnail->getName() );
// confirm thumbnail dimensions
$expectedSize = $size ?? SearchResultThumbnailProvider::THUMBNAIL_SIZE;
$this->assertLessThanOrEqual( $expectedSize, $thumbnail->getWidth() );
}
}
}
PK ! b2 2 search/TitleMatcherTest.phpnu Iw overrideConfigValue( MainConfigNames::UsePigLatinVariant, false );
}
public static function nearMatchProvider() {
return [
'empty request returns nothing' => [ null, 'en', '', 'Near Match Test' ],
'with a hash returns nothing' => [ null, 'en', '#near match test', 'Near Match Test' ],
'wrong seach string returns nothing' => [
null, 'en', ':', 'Near Match Test'
],
'default behaviour exact' => [
'Near Match Test', 'en', 'Near Match Test', 'Near Match Test'
],
'default behaviour uppercased' => [
'NEAR MATCH TEST', 'en', 'near match test', 'NEAR MATCH TEST'
],
'default behaviour first capitalized' => [
'Near match test', 'en', 'near match test', 'Near match test'
],
'default behaviour capitalized' => [
'Near Match Test', 'en', 'near match test', 'Near Match Test'
],
'default behaviour lowercased' => [
'Near match test', 'en', 'NEAR MATCH TEST', 'Near match test'
],
'default behaviour hyphenated' => [
'Near-Match-Test', 'en', 'near-match-test', 'Near-Match-Test'
],
'default behaviour quoted' => [
'Near Match Test', 'en', '"Near Match Test"', 'Near Match Test'
],
'check language with variants direct' => [ 'Near', 'tg', 'near', 'Near' ],
'check language with variants converted' => [ 'Near', 'tg', 'неар', 'Near' ],
'no matching' => [ null, 'en', 'near match test', 'Far Match Test' ],
// Special cases: files
'file ok' => [ 'File:Example.svg', 'en', 'File:Example.svg', 'File:Example.svg' ],
'file not ok' => [ null, 'en', 'File:Example_s.svg', 'File:Example.svg' ],
// Special cases: users
'user ok' => [ 'User:Superuser', 'en', 'User:Superuser', 'User:Superuser' ],
'user ok even if no user' => [
'User:SuperuserNew', 'en', 'User:SuperuserNew', 'User:Superuser'
],
'user search use by IP' => [
'Special:Contributions/132.17.48.1', 'en', 'User:132.17.48.1', 'User:Superuser', true,
],
// Special cases: other content types
'mediawiki ok even if no page' => [
'MediaWiki:Add New Page', 'en', 'MediaWiki:Add New Page', 'MediaWiki:Add Old Page'
],
'Media ok' => [
'File:Text', 'en', 'Media:Text', 'File:Text', true,
],
'Media not ok' => [
null, 'en', 'Media:Text', 'Media:Text', true,
],
];
}
/**
* @param HashConfig $config
* @param string $langCode
*
* @return TitleMatcher
*/
private function getTitleMatcher( HashConfig $config, $langCode ): TitleMatcher {
$services = $this->getServiceContainer();
return new TitleMatcher(
new ServiceOptions( TitleMatcher::CONSTRUCTOR_OPTIONS, $config ),
$services->getLanguageFactory()->getLanguage( $langCode ),
$services->getLanguageConverterFactory(),
$services->getHookContainer(),
$services->getWikiPageFactory(),
$services->getUserNameUtils(),
$services->getRepoGroup(),
$services->getTitleFactory()
);
}
/**
* @dataProvider nearMatchProvider
* @covers \MediaWiki\Search\TitleMatcher::getNearMatchInternal
* @covers \MediaWiki\Search\TitleMatcher::getNearMatch
*/
public function testNearMatch(
$expected,
$langCode,
$searchterm,
$titleText,
$enableSearchContributorsByIP = false
) {
$this->overrideConfigValue( MainConfigNames::LanguageCode, 'en' );
$this->addGoodLinkObject( 42, Title::newFromText( $titleText ) );
$config = new HashConfig( [
MainConfigNames::EnableSearchContributorsByIP => $enableSearchContributorsByIP,
] );
$matcher = $this->getTitleMatcher( $config, $langCode );
$title = $matcher->getNearMatch( $searchterm );
$this->assertEquals( $expected, $title === null ? null : (string)$title );
}
public static function hooksProvider() {
return [
'SearchGetNearMatchBefore' => [ 'SearchGetNearMatchBefore' ],
'SearchAfterNoDirectMatch' => [ 'SearchAfterNoDirectMatch' ],
'SearchGetNearMatch' => [ 'SearchGetNearMatch' ]
];
}
/**
* @dataProvider hooksProvider
* @covers \MediaWiki\Search\TitleMatcher::getNearMatchInternal
* @covers \MediaWiki\Search\TitleMatcher::getNearMatch
*/
public function testNearMatch_Hooks( $hook ) {
$config = new HashConfig( [
MainConfigNames::EnableSearchContributorsByIP => false,
] );
$this->setTemporaryHook( $hook, static function ( $term, &$title ) {
if ( $term === [ 'Hook' ] || $term === 'Hook' ) {
$title = Title::makeTitle( NS_MAIN, 'TitleFromHook' );
return false;
}
return null;
} );
$matcher = $this->getTitleMatcher( $config, 'en' );
$title = $matcher->getNearMatch( 'Hook' );
$this->assertEquals( 'TitleFromHook', $title );
$this->assertNull( $matcher->getNearMatch( 'OtherHook' ) );
}
/**
* @covers \MediaWiki\Search\TitleMatcher::getNearMatchResultSet
*/
public function testGetNearMatchResultSet() {
$this->addGoodLinkObject( 42, Title::makeTitle( NS_MAIN, "Test Link" ) );
$config = new HashConfig( [
MainConfigNames::EnableSearchContributorsByIP => false,
] );
$matcher = $this->getTitleMatcher( $config, 'en' );
$result = $matcher->getNearMatchResultSet( 'Test Link' );
$this->assertSame( 1, $result->numRows() );
$result = $matcher->getNearMatchResultSet( 'Test Link Wrong' );
$this->assertSame( 0, $result->numRows() );
}
protected function tearDown(): void {
Title::clearCaches();
parent::tearDown();
}
}
PK ! F& search/SearchResultTraitTest.phpnu Iw assertEquals( [], $result->getExtensionData(), 'starts empty' );
$data = [ 'hello' => 'world' ];
$result->setExtensionData( static function () use ( &$data ) {
return $data;
} );
$this->assertEquals( $data, $result->getExtensionData(), 'can set extension data' );
$data['this'] = 'that';
$this->assertEquals( $data, $result->getExtensionData(), 'refetches from callback' );
}
/**
* @covers \SearchResultTrait::getExtensionData
* @covers \SearchResultTrait::setExtensionData
*/
public function testExtensionDataArrayBC() {
$result = new class() {
use SearchResultTrait;
};
$data = [ 'hello' => 'world' ];
$this->hideDeprecated( 'SearchResultTrait::setExtensionData with array argument' );
$this->assertEquals( [], $result->getExtensionData(), 'starts empty' );
$result->setExtensionData( $data );
$this->assertEquals( $data, $result->getExtensionData(), 'can set extension data' );
$data['this'] = 'that';
$this->assertNotEquals( $data, $result->getExtensionData(), 'shouldnt hold any reference' );
$result->setExtensionData( $data );
$this->assertEquals( $data, $result->getExtensionData(), 'can replace extension data' );
}
}
PK ! H@ @ search/SearchEngineTest.phpnu Iw
* @note Coverage will only ever show one of on of the Search* classes
*/
class SearchEngineTest extends MediaWikiLangTestCase {
/**
* @var SearchEngine
*/
protected $search;
/**
* Checks for database type & version.
* Will skip current test if DB does not support search.
*/
protected function setUp(): void {
parent::setUp();
// Search tests require MySQL or SQLite with FTS
$dbType = $this->getDb()->getType();
$dbSupported = ( $dbType === 'mysql' )
|| ( $dbType === 'sqlite' && $this->getDb()->getFulltextSearchModule() == 'FTS3' );
if ( !$dbSupported ) {
$this->markTestSkipped( "MySQL or SQLite with FTS3 only" );
}
$dbProvider = $this->getServiceContainer()->getConnectionProvider();
$searchType = SearchEngineFactory::getSearchEngineClass( $dbProvider );
$this->overrideConfigValues( [
MainConfigNames::SearchType => $searchType,
MainConfigNames::CapitalLinks => true,
MainConfigNames::CapitalLinkOverrides => [
NS_CATEGORY => false // for testCompletionSearchMustRespectCapitalLinkOverrides
],
] );
$this->search = new $searchType( $dbProvider );
$this->search->setHookContainer( $this->getServiceContainer()->getHookContainer() );
}
protected function tearDown(): void {
unset( $this->search );
parent::tearDown();
}
public function addDBDataOnce() {
if ( !$this->isWikitextNS( NS_MAIN ) ) {
// @todo cover the case of non-wikitext content in the main namespace
return;
}
// Reset the search type back to default - some extensions may have
// overridden it.
$this->overrideConfigValues( [
MainConfigNames::SearchType => null,
MainConfigNames::CapitalLinks => true,
MainConfigNames::CapitalLinkOverrides => [
NS_CATEGORY => false // for testCompletionSearchMustRespectCapitalLinkOverrides
],
] );
$this->insertPage( 'Not_Main_Page', 'This is not a main page' );
$this->insertPage(
'Talk:Not_Main_Page',
'This is not a talk page to the main page, see [[smithee]]'
);
$this->insertPage( 'Smithee', 'A smithee is one who smiths. See also [[Alan Smithee]]' );
$this->insertPage( 'Talk:Smithee', 'This article sucks.' );
$this->insertPage( 'Unrelated_page', 'Nothing in this page is about the S word.' );
$this->insertPage( 'Another_page', 'This page also is unrelated.' );
$this->insertPage( 'Help:Help', 'Help me!' );
$this->insertPage( 'Thppt', 'Blah blah' );
$this->insertPage( 'Alan_Smithee', 'yum' );
$this->insertPage( 'Pages', 'are\'food' );
$this->insertPage( 'HalfOneUp', 'AZ' );
$this->insertPage( 'FullOneUp', 'ＡＺ' );
$this->insertPage( 'HalfTwoLow', 'az' );
$this->insertPage( 'FullTwoLow', 'ａｚ' );
$this->insertPage( 'HalfNumbers', '1234567890' );
$this->insertPage( 'FullNumbers', '１２３４５６７８９０' );
$this->insertPage( 'DomainName', 'example.com' );
$this->insertPage( 'DomainName', 'example.com' );
$this->insertPage( 'Category:search is not Search', '' );
$this->insertPage( 'Category:Search is not search', '' );
$this->insertPage( 'Talk:1', 'Did you know titles can be numbers?' );
}
protected function fetchIds( $results ) {
if ( !$this->isWikitextNS( NS_MAIN ) ) {
$this->markTestIncomplete( __CLASS__ . " does no yet support non-wikitext content "
. "in the main namespace" );
}
$this->assertIsObject( $results );
$matches = [];
foreach ( $results as $row ) {
$matches[] = $row->getTitle()->getPrefixedText();
}
$results->free();
# Search is not guaranteed to return results in a certain order;
# sort them numerically so we will compare simply that we received
# the expected matches.
sort( $matches );
return $matches;
}
public function testFullWidth() {
// T303046
$this->markTestSkippedIfDbType( 'sqlite' );
$this->assertEquals(
[ 'FullOneUp', 'FullTwoLow', 'HalfOneUp', 'HalfTwoLow' ],
$this->fetchIds( $this->search->searchText( 'AZ' ) ),
"Search for normalized from Half-width Upper" );
$this->assertEquals(
[ 'FullOneUp', 'FullTwoLow', 'HalfOneUp', 'HalfTwoLow' ],
$this->fetchIds( $this->search->searchText( 'az' ) ),
"Search for normalized from Half-width Lower" );
$this->assertEquals(
[ 'FullOneUp', 'FullTwoLow', 'HalfOneUp', 'HalfTwoLow' ],
$this->fetchIds( $this->search->searchText( 'ＡＺ' ) ),
"Search for normalized from Full-width Upper" );
$this->assertEquals(
[ 'FullOneUp', 'FullTwoLow', 'HalfOneUp', 'HalfTwoLow' ],
$this->fetchIds( $this->search->searchText( 'ａｚ' ) ),
"Search for normalized from Full-width Lower" );
}
public function testTextSearch() {
// T303046
$this->markTestSkippedIfDbType( 'sqlite' );
$this->assertEquals(
[ 'Smithee' ],
$this->fetchIds( $this->search->searchText( 'smithee' ) ),
"Plain search" );
}
public function testWildcardSearch() {
// T303046
$this->markTestSkippedIfDbType( 'sqlite' );
$res = $this->search->searchText( 'smith*' );
$this->assertEquals(
[ 'Smithee' ],
$this->fetchIds( $res ),
"Search with wildcards" );
$res = $this->search->searchText( 'smithson*' );
$this->assertEquals(
[],
$this->fetchIds( $res ),
"Search with wildcards must not find unrelated articles" );
$res = $this->search->searchText( 'smith* smithee' );
$this->assertEquals(
[ 'Smithee' ],
$this->fetchIds( $res ),
"Search with wildcards can be combined with simple terms" );
$res = $this->search->searchText( 'smith* "one who smiths"' );
$this->assertEquals(
[ 'Smithee' ],
$this->fetchIds( $res ),
"Search with wildcards can be combined with phrase search" );
}
public function testPhraseSearch() {
// T303046
$this->markTestSkippedIfDbType( 'sqlite' );
$res = $this->search->searchText( '"smithee is one who smiths"' );
$this->assertEquals(
[ 'Smithee' ],
$this->fetchIds( $res ),
"Search a phrase" );
$res = $this->search->searchText( '"smithee is who smiths"' );
$this->assertEquals(
[],
$this->fetchIds( $res ),
"Phrase search is not sloppy, search terms must be adjacent" );
$res = $this->search->searchText( '"is smithee one who smiths"' );
$this->assertEquals(
[],
$this->fetchIds( $res ),
"Phrase search is ordered" );
}
public function testPhraseSearchHighlight() {
// T303046
$this->markTestSkippedIfDbType( 'sqlite' );
$phrase = "smithee is one who smiths";
$res = $this->search->searchText( "\"$phrase\"" );
$match = $res->getIterator()->current();
$snippet = 'A ' . $phrase . '';
$this->assertStringStartsWith( $snippet,
$match->getTextSnippet(),
"Highlight a phrase search" );
}
public function testTextPowerSearch() {
// T303046
$this->markTestSkippedIfDbType( 'sqlite' );
$this->search->setNamespaces( [ 0, 1, 4 ] );
$this->assertEquals(
[
'Smithee',
'Talk:Not Main Page',
],
$this->fetchIds( $this->search->searchText( 'smithee' ) ),
"Power search" );
}
public function testTitleSearch() {
// T303046
$this->markTestSkippedIfDbType( 'sqlite' );
$this->assertEquals(
[
'Alan Smithee',
'Smithee',
],
$this->fetchIds( $this->search->searchTitle( 'smithee' ) ),
"Title search" );
}
public function testTextTitlePowerSearch() {
// T303046
$this->markTestSkippedIfDbType( 'sqlite' );
$this->search->setNamespaces( [ 0, 1, 4 ] );
$this->assertEquals(
[
'Alan Smithee',
'Smithee',
'Talk:Smithee',
],
$this->fetchIds( $this->search->searchTitle( 'smithee' ) ),
"Title power search" );
}
public static function provideCompletionSearchMustRespectCapitalLinkOverrides() {
return [
'Searching for "smithee" finds Smithee on NS_MAIN' => [
'smithee',
'Smithee',
[ NS_MAIN ],
],
'Searching for "search is" will finds "search is not Search" on NS_CATEGORY' => [
'search is',
'Category:search is not Search',
[ NS_CATEGORY ],
],
'Searching for "Search is" will finds "search is not Search" on NS_CATEGORY' => [
'Search is',
'Category:Search is not search',
[ NS_CATEGORY ],
],
'Copy-pasted wikilinks with invalid characters will still find the page' => [
'[[smithee]]',
'Smithee',
[ NS_MAIN ],
],
'Numeric title works (T365565)' => [
'1',
'Talk:1',
[ NS_TALK ],
]
];
}
/**
* Test that the search query is not munged using wrong CapitalLinks setup
* (in other test that the default search backend can benefit from wgCapitalLinksOverride)
* Guard against regressions like T208255
* @dataProvider provideCompletionSearchMustRespectCapitalLinkOverrides
* @covers \SearchEngine::completionSearch
* @covers \PrefixSearch::defaultSearchBackend
* @param string $search
* @param string $expectedSuggestion
* @param int[] $namespaces
*/
public function testCompletionSearchMustRespectCapitalLinkOverrides(
$search,
$expectedSuggestion,
array $namespaces
) {
$this->search->setNamespaces( $namespaces );
$results = $this->search->completionSearch( $search );
$this->assertSame( 1, $results->getSize() );
$this->assertEquals( $expectedSuggestion, $results->getSuggestions()[0]->getText() );
}
/**
* @covers \SearchEngine::getSearchIndexFields
*/
public function testSearchIndexFields() {
/**
* @var SearchEngine $mockEngine
*/
$mockEngine = $this->getMockBuilder( SearchEngine::class )
->onlyMethods( [ 'makeSearchFieldMapping' ] )->getMock();
$mockFieldBuilder = function ( $name, $type ) {
$mockField =
$this->getMockBuilder( SearchIndexFieldDefinition::class )->setConstructorArgs( [
$name,
$type,
] )->getMock();
$mockField->method( 'getMapping' )->willReturn( [
'testData' => 'test',
'name' => $name,
'type' => $type,
] );
$mockField->method( 'merge' )->willReturnSelf();
return $mockField;
};
$mockEngine->expects( $this->atLeastOnce() )
->method( 'makeSearchFieldMapping' )
->willReturnCallback( $mockFieldBuilder );
// Not using mock since PHPUnit mocks do not work properly with references in params
$this->setTemporaryHook( 'SearchIndexFields',
static function ( &$fields, SearchEngine $engine ) use ( $mockFieldBuilder ) {
$fields['testField'] =
$mockFieldBuilder( "testField", SearchIndexField::INDEX_TYPE_TEXT );
return true;
} );
$mockEngine->setHookContainer( $this->getServiceContainer()->getHookContainer() );
$fields = $mockEngine->getSearchIndexFields();
$this->assertArrayHasKey( 'language', $fields );
$this->assertArrayHasKey( 'category', $fields );
$this->assertInstanceOf( SearchIndexField::class, $fields['testField'] );
$mapping = $fields['testField']->getMapping( $mockEngine );
$this->assertArrayHasKey( 'testData', $mapping );
$this->assertEquals( 'test', $mapping['testData'] );
}
public function hookSearchIndexFields( $mockFieldBuilder, &$fields, SearchEngine $engine ) {
$fields['testField'] = $mockFieldBuilder( "testField", SearchIndexField::INDEX_TYPE_TEXT );
return true;
}
public function testAugmentorSearch() {
// T303046
$this->markTestSkippedIfDbType( 'sqlite' );
$this->search->setHookContainer(
$this->createHookContainer( [ 'SearchResultsAugment' => [ $this, 'addAugmentors' ] ] )
);
$this->search->setNamespaces( [ 0, 1, 4 ] );
$resultSet = $this->search->searchText( 'smithee' );
$this->search->augmentSearchResults( $resultSet );
foreach ( $resultSet as $result ) {
$id = $result->getTitle()->getArticleID();
$augmentData = "Result:$id:" . $result->getTitle()->getText();
$augmentData2 = "Result2:$id:" . $result->getTitle()->getText();
$this->assertEquals( [ 'testSet' => $augmentData, 'testRow' => $augmentData2 ],
$result->getExtensionData() );
}
}
public function addAugmentors( &$setAugmentors, &$rowAugmentors ) {
$setAugmentor = $this->createMock( ResultSetAugmentor::class );
$setAugmentor->expects( $this->once() )
->method( 'augmentAll' )
->willReturnCallback( static function ( ISearchResultSet $resultSet ) {
$data = [];
/** @var SearchResult $result */
foreach ( $resultSet as $result ) {
$id = $result->getTitle()->getArticleID();
$data[$id] = "Result:$id:" . $result->getTitle()->getText();
}
return $data;
} );
$setAugmentors['testSet'] = $setAugmentor;
$rowAugmentor = $this->createMock( ResultAugmentor::class );
$rowAugmentor->expects( $this->exactly( 2 ) )
->method( 'augment' )
->willReturnCallback( static function ( SearchResult $result ) {
$id = $result->getTitle()->getArticleID();
return "Result2:$id:" . $result->getTitle()->getText();
} );
$rowAugmentors['testRow'] = $rowAugmentor;
}
public function testFiltersMissing() {
$availableResults = [];
$user = $this->getTestSysop()->getAuthority();
foreach ( range( 0, 11 ) as $i ) {
$title = "Search_Result_$i";
$availableResults[] = $title;
// pages not created must be filtered
if ( $i % 2 == 0 ) {
$this->editPage(
$title,
new WikitextContent( 'TestFiltersMissing content' ),
'TestFiltersMissing summary',
NS_MAIN,
$user
);
}
}
MockCompletionSearchEngine::addMockResults( 'foo', $availableResults );
$engine = new MockCompletionSearchEngine();
$engine->setLimitOffset( 10, 0 );
$engine->setHookContainer( $this->getServiceContainer()->getHookContainer() );
$results = $engine->completionSearch( 'foo' );
$this->assertEquals( 5, $results->getSize() );
$this->assertTrue( $results->hasMoreResults() );
$engine->setLimitOffset( 10, 10 );
$results = $engine->completionSearch( 'foo' );
$this->assertSame( 1, $results->getSize() );
$this->assertFalse( $results->hasMoreResults() );
}
public static function provideDataForParseNamespacePrefix() {
return [
'noop' => [
[
'query' => 'foo',
],
false,
],
'empty' => [
[
'query' => '',
],
false,
],
'namespace prefix' => [
[
'query' => 'help:test',
],
[ 'test', [ NS_HELP ] ],
],
'accented namespace prefix with hook' => [
[
'query' => 'hélp:test',
'withHook' => true,
],
[ 'test', [ NS_HELP ] ],
],
'accented namespace prefix without hook' => [
[
'query' => 'hélp:test',
'withHook' => false,
],
false,
],
'all with all keyword allowed' => [
[
'query' => 'all:test',
'withAll' => true,
],
[ 'test', null ],
],
'all with all keyword disallowed' => [
[
'query' => 'all:test',
'withAll' => false,
],
false,
],
'ns only' => [
[
'query' => 'help:',
],
[ '', [ NS_HELP ] ],
],
'all only' => [
[
'query' => 'all:',
'withAll' => true,
],
[ '', null ],
],
'all wins over namespace when first' => [
[
'query' => 'all:help:test',
'withAll' => true,
],
[ 'help:test', null ],
],
'ns wins over all when first' => [
[
'query' => 'help:all:test',
'withAll' => true,
],
[ 'all:test', [ NS_HELP ] ],
],
];
}
/**
* @dataProvider provideDataForParseNamespacePrefix
*/
public function testParseNamespacePrefix( array $params, $expected ) {
$this->setTemporaryHook( 'PrefixSearchExtractNamespace', static function ( &$namespaces, &$query ) {
if ( str_starts_with( $query, 'hélp:' ) ) {
$namespaces = [ NS_HELP ];
$query = substr( $query, strlen( 'hélp:' ) );
}
return false;
} );
$testSet = [];
if ( isset( $params['withAll'] ) && isset( $params['withHook'] ) ) {
$testSet[] = $params;
} elseif ( isset( $params['withAll'] ) ) {
$testSet[] = $params + [ 'withHook' => true ];
$testSet[] = $params + [ 'withHook' => false ];
} elseif ( isset( $params['withHook'] ) ) {
$testSet[] = $params + [ 'withAll' => true ];
$testSet[] = $params + [ 'withAll' => false ];
} else {
$testSet[] = $params + [ 'withAll' => true, 'withHook' => true ];
$testSet[] = $params + [ 'withAll' => true, 'withHook' => false ];
$testSet[] = $params + [ 'withAll' => false, 'withHook' => false ];
$testSet[] = $params + [ 'withAll' => true, 'withHook' => false ];
}
foreach ( $testSet as $test ) {
$actual = SearchEngine::parseNamespacePrefixes( $test['query'],
$test['withAll'], $test['withHook'] );
$this->assertEquals( $expected, $actual, 'with params: ' . print_r( $test, true ) );
}
}
}
PK ! /:) ) ( editpage/PreloadedContentBuilderTest.phpnu Iw getServiceContainer();
// Needed for the 'Default preload section' test case due to use of wfMessage()
$this->overrideConfigValue( MainConfigNames::UseDatabaseMessages, true );
$this->preloadedContentBuilder = $services->getPreloadedContentBuilder();
}
public static function provideCases() {
// title, preload, preloadParams, section, pages, expectedContent
yield 'Non-existent page, no preload' =>
[ 'Does-not-exist-asdfasdf', null, [], null, [],
"" ];
yield 'Non-existent page, preload' =>
[ 'Does-not-exist-asdfasdf', 'Template:Preload', [], null, [ 'Template:Preload' => 'Preload' ],
"Preload" ];
yield 'Non-existent page, preload with parameters' =>
[ 'Does-not-exist-asdfasdf', 'Template:Preloadparams', [ 'a', 'b' ], null, [ 'Template:Preloadparams' => 'Preload $1 $2' ],
"Preload a b" ];
yield 'Existing page content is ignored (it is not our responsibility)' =>
[ 'Exists', null, [], null, [ 'Exists' => 'Hello' ],
"" ];
yield 'Existing page content is ignored (it is not our responsibility), preload' =>
[ 'Exists', 'Template:Preload', [], null, [ 'Exists' => 'Hello', 'Template:Preload' => 'Preload' ],
"Preload" ];
yield 'Preload section' =>
[ 'Exists', 'Template:Preload', [], 'new', [ 'Exists' => 'Hello', 'Template:Preload' => 'Preload' ],
"Preload" ];
yield 'Default preload section' =>
[ 'Exists', null, [], 'new', [ 'Exists' => 'Hello', 'MediaWiki:Addsection-preload' => 'Preloadsection' ],
"Preloadsection" ];
yield 'Non-existent page in MediaWiki: namespace is prefilled with message' =>
[ 'MediaWiki:View', null, [], null, [],
"View" ];
yield 'Non-existent page in MediaWiki: namespace for non-existent message' =>
[ 'MediaWiki:Does-not-exist-asdfasdf', null, [], null, [],
"" ];
yield 'Non-existent page in MediaWiki: namespace does not support preload' =>
[ 'MediaWiki:View', 'Template:Preload', [], null, [ 'Template:Preload' => 'Preload' ],
"View" ];
yield 'Non-existent message supports preload' =>
[ 'MediaWiki:Does-not-exist-asdfasdf', 'Template:Preload', [], null, [ 'Template:Preload' => 'Preload' ],
"Preload" ];
yield 'JSON page in MediaWiki: namespace is prefilled with empty JSON' =>
[ 'MediaWiki:Foo.json', null, [], null, [],
"{}" ];
yield 'Preload using Special:MyLanguage' =>
[ 'Does-not-exist-asdfasdf', 'Special:MyLanguage/Template:Preload', [], null, [ 'Template:Preload' => 'Preload' ],
"Preload" ];
yield 'Preload using a localisation message' =>
[ 'Does-not-exist-asdfasdf', 'MediaWiki:View', [], null, [],
"View" ];
yield 'Preload using a page in mediawiki namespace' =>
[ 'Does-not-exist-asdfasdf', 'MediaWiki:For-preloading', [], null, [ 'MediaWiki:For-preloading' => 'Noinclude Includeonly ' ],
"Includeonly" ];
yield 'Preload over redirect' =>
[ 'Does-not-exist-asdfasdf', 'Template:Preload2', [], null, [ 'Template:Preload' => 'Preload', 'Template:Preload2' => '#REDIRECT[[Template:Preload]]' ],
"Preload" ];
}
/**
* @dataProvider provideCases
*/
public function testGetPreloadedContent( $title, $preload, $preloadParams, $section, $pages, $expectedContent ) {
foreach ( $pages as $page => $content ) {
$this->editPage( $page, $content );
}
$content = $this->preloadedContentBuilder->getPreloadedContent(
Title::newFromText( $title )->toPageIdentity(),
new UltimateAuthority( $this->getTestUser()->getUser() ),
$preload,
$preloadParams,
$section
);
$this->assertEquals( $expectedContent, $content->serialize() );
}
}
PK ! ^%W W editpage/TextboxBuilderTest.phpnu Iw
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
*/
namespace MediaWiki\Tests\EditPage;
use MediaWiki\EditPage\TextboxBuilder;
use MediaWiki\Language\Language;
use MediaWiki\MainConfigNames;
use MediaWiki\Page\PageIdentityValue;
use MediaWiki\Permissions\RestrictionStore;
use MediaWiki\Title\Title;
use MediaWiki\User\Options\StaticUserOptionsLookup;
use MediaWiki\User\UserIdentityValue;
use MediaWikiIntegrationTestCase;
/**
* See also unit tests at \MediaWiki\Tests\Unit\EditPage\TextboxBuilderTest
*
* @covers \MediaWiki\EditPage\TextboxBuilder
*/
class TextboxBuilderTest extends MediaWikiIntegrationTestCase {
public static function provideGetTextboxProtectionCSSClasses() {
return [
[
[ '' ],
[ 'isProtected' ],
[],
],
[
[ '', 'something' ],
[],
[],
],
[
[ '', 'something' ],
[ 'isProtected' ],
[ 'mw-textarea-protected' ]
],
[
[ '', 'something' ],
[ 'isProtected', 'isSemiProtected' ],
[ 'mw-textarea-sprotected' ],
],
[
[ '', 'something' ],
[ 'isProtected', 'isCascadeProtected' ],
[ 'mw-textarea-protected', 'mw-textarea-cprotected' ],
],
[
[ '', 'something' ],
[ 'isProtected', 'isCascadeProtected', 'isSemiProtected' ],
[ 'mw-textarea-sprotected', 'mw-textarea-cprotected' ],
],
];
}
/**
* @dataProvider provideGetTextboxProtectionCSSClasses
*/
public function testGetTextboxProtectionCSSClasses(
$restrictionLevels,
$protectionModes,
$expected
) {
$this->overrideConfigValue(
// set to trick PermissionManager::getNamespaceRestrictionLevels
MainConfigNames::RestrictionLevels, $restrictionLevels
);
$mockRestrictionStore = $this->createMock( RestrictionStore::class );
$pageIdValue = PageIdentityValue::localIdentity( 1, NS_MAIN, 'test' );
$mockRestrictionStore->method(
$this->logicalOr( ...array_map( [ $this, 'identicalTo' ], $protectionModes ) )
)->willReturn( true );
$this->setService( 'RestrictionStore', $mockRestrictionStore );
$builder = new TextboxBuilder();
$this->assertSame( $expected, $builder->getTextboxProtectionCSSClasses( $pageIdValue ) );
}
public function testBuildTextboxAttribs() {
$user = UserIdentityValue::newRegistered( 42, 'Test' );
$mockUserOptionsLookup = new StaticUserOptionsLookup( [
'Test' => [ 'editfont' => 'monospace' ],
] );
$this->setService( 'UserOptionsLookup', $mockUserOptionsLookup );
$enLanguage = $this->createMock( Language::class );
$enLanguage->method( 'getHtmlCode' )->willReturn( 'en' );
$enLanguage->method( 'getDir' )->willReturn( 'ltr' );
$title = $this->createMock( Title::class );
$title->method( 'getPageLanguage' )->willReturn( $enLanguage );
$builder = new TextboxBuilder();
$attribs = $builder->buildTextboxAttribs(
'mw-textbox1',
[ 'class' => 'foo bar', 'data-foo' => '123', 'rows' => 30 ],
$user,
$title
);
$this->assertIsArray( $attribs );
// custom attrib showed up
$this->assertArrayHasKey( 'data-foo', $attribs );
// classes merged properly (string)
$this->assertSame( 'foo bar mw-editfont-monospace', $attribs['class'] );
// overrides in custom attrib worked
$this->assertSame( 30, $attribs['rows'] );
$this->assertSame( 'en', $attribs['lang'] );
$attribs2 = $builder->buildTextboxAttribs(
'mw-textbox2', [ 'class' => [ 'foo', 'bar' ] ], $user, $title
);
// classes merged properly (array)
$this->assertSame( [ 'foo', 'bar', 'mw-editfont-monospace' ], $attribs2['class'] );
$attribs3 = $builder->buildTextboxAttribs(
'mw-textbox3', [], $user, $title
);
// classes ok when nothing to be merged
$this->assertSame( 'mw-editfont-monospace', $attribs3['class'] );
}
}
PK ! ,]v v editpage/EditPageTest.phpnu Iw overrideConfigValues( [
MainConfigNames::ExtraNamespaces => [
12312 => 'Dummy',
12313 => 'Dummy_talk',
],
MainConfigNames::NamespaceContentModels => [ 12312 => 'testing' ],
MainConfigNames::ContentHandlers =>
[ 'testing' => 'DummyContentHandlerForTesting' ] +
MainConfigSchema::getDefaultValue( MainConfigNames::ContentHandlers ),
] );
// Disable WAN cache to avoid edit conflicts in testUpdateNoMinor
$this->setMainCache( CACHE_NONE );
}
public function addDBDataOnce() {
$userFactory = $this->getServiceContainer()->getUserFactory();
self::$editUsers = [
'anon' => new User(),
'UTSysop' => $userFactory->newFromName( 'UTSysop' ),
'user' => $userFactory->newFromName( 'UTUser' ),
'Adam' => $userFactory->newFromName( 'Adam' ),
'Berta' => $userFactory->newFromName( 'Berta' ),
'Elmo' => $userFactory->newFromName( 'Elmo' ),
];
foreach ( self::$editUsers as $key => $user ) {
if ( $key !== 'anon' ) {
$user->addToDatabase();
}
}
$groupManager = $this->getServiceContainer()->getUserGroupManager();
$groupManager->addUserToMultipleGroups(
self::$editUsers['UTSysop'], [ 'sysop', 'bureaucrat' ] );
}
/**
* @dataProvider provideExtractSectionTitle
* @covers \MediaWiki\EditPage\EditPage::extractSectionTitle
*/
public function testExtractSectionTitle( $section, $title ) {
$this->assertEquals(
$title,
TestingAccessWrapper::newFromClass( EditPage::class )->extractSectionTitle( $section )
);
}
public static function provideExtractSectionTitle() {
return [
[
"== Test ==\n\nJust a test section.",
"Test"
],
[
"An initial section, no header.",
false
],
[
"An initial section with a fake heder (T34617)\n\n== Test == ??\nwtf",
false
],
[
"== Section ==\nfollowed by a fake == Non-section == ??\nnoooo",
"Section"
],
[
"== Section== \t\r\n followed by whitespace (T37051)",
'Section',
],
];
}
protected function forceRevisionDate( WikiPage $page, $timestamp ) {
$dbw = $this->getDb();
$dbw->newUpdateQueryBuilder()
->update( 'revision' )
->set( [ 'rev_timestamp' => $dbw->timestamp( $timestamp ) ] )
->where( [ 'rev_id' => $page->getLatest() ] )
->execute();
$page->clear();
}
/**
* User input text is passed to rtrim() by edit page. This is a simple
* wrapper around assertEquals() which calls rrtrim() to normalize the
* expected and actual texts.
* @param string $expected
* @param string $actual
* @param string $msg
*/
protected function assertEditedTextEquals( $expected, $actual, $msg = '' ) {
$this->assertEquals( rtrim( $expected ), rtrim( $actual ), $msg );
}
/**
* Performs an edit and checks the result.
*
* @param string|Title $title The title of the page to edit
* @param string|null $baseText Some text to create the page with before attempting the edit.
* @param string $userKey The user to perform the edit as.
* @param array $edit An array of request parameters used to define the edit to perform.
* Some well known fields are:
* * wpTextbox1: the text to submit
* * wpSummary: the edit summary
* * wpEditToken: the edit token (will be inserted if not provided)
* * wpEdittime: timestamp of the edit's base revision (will be inserted
* if not provided)
* * editRevId: revision ID of the edit's base revision (optional)
* * wpStarttime: timestamp when the edit started (will be inserted if not provided)
* * wpSectionTitle: the section to edit
* * wpMinoredit: mark as minor edit
* * wpWatchthis: whether to watch the page
* @param int|null $expectedCode The expected result code (EditPage::AS_XXX constants).
* Set to null to skip the check.
* @param string|null $expectedText The text expected to be on the page after the edit.
* Set to null to skip the check.
* @param string|null $message An optional message to show along with any error message.
*
* @return WikiPage The page that was just edited, useful for getting the edit's rev_id, etc.
*/
protected function assertEdit( $title, $baseText, $userKey, array $edit,
$expectedCode = null, $expectedText = null, $message = null
) {
if ( is_string( $title ) ) {
$ns = $this->getDefaultWikitextNS();
$title = Title::newFromText( $title, $ns );
}
$this->assertNotNull( $title );
if ( !isset( self::$editUsers[$userKey] ) ) {
$this->fail( "User $userKey not registered in addDBDataOnce" );
}
$user = self::$editUsers[$userKey];
$wikiPageFactory = $this->getServiceContainer()->getWikiPageFactory();
$page = $wikiPageFactory->newFromTitle( $title );
if ( $baseText !== null ) {
$content = ContentHandler::makeContent( $baseText, $title );
$page->doUserEditContent( $content, $user, "base text for test" );
$this->forceRevisionDate( $page, '20120101000000' );
$page->clear();
$content = $page->getContent();
$this->assertInstanceOf( TextContent::class, $content );
$currentText = $content->getText();
# EditPage rtrim() the user input, so we alter our expected text
# to reflect that.
$this->assertEditedTextEquals( $baseText, $currentText );
}
if ( !isset( $edit['wpEditToken'] ) ) {
$edit['wpEditToken'] = $user->getEditToken();
}
if ( !isset( $edit['wpEdittime'] ) && !isset( $edit['editRevId'] ) ) {
$edit['wpEdittime'] = $page->exists() ? $page->getTimestamp() : '';
}
if ( !isset( $edit['wpStarttime'] ) ) {
$edit['wpStarttime'] = wfTimestampNow();
}
if ( !isset( $edit['wpUnicodeCheck'] ) ) {
$edit['wpUnicodeCheck'] = EditPage::UNICODE_CHECK;
}
$req = new FauxRequest( $edit, true ); // session ??
$context = new RequestContext();
$context->setRequest( $req );
$context->setTitle( $title );
$context->setUser( $user );
$article = new Article( $title );
$article->setContext( $context );
$ep = new EditPage( $article );
$ep->setContextTitle( $title );
$ep->importFormData( $req );
// this is where the edit happens!
// Note: don't want to use EditPage::AttemptSave, because it messes with $wgOut
// and throws exceptions like PermissionsError
$status = $ep->attemptSave( $result );
if ( $expectedCode !== null ) {
// check edit code
$this->assertEquals( $expectedCode, $status->value,
"Expected result code mismatch. $message" );
}
$page = $wikiPageFactory->newFromTitle( $title );
if ( $expectedText !== null ) {
// check resulting page text
$content = $page->getContent();
$text = ( $content instanceof TextContent ) ? $content->getText() : '';
# EditPage rtrim() the user input, so we alter our expected text
# to reflect that.
$this->assertEditedTextEquals( $expectedText, $text,
"Expected article text mismatch. $message" );
}
return $page;
}
public static function provideCreatePages() {
return [
[ 'expected article being created',
'EditPageTest_testCreatePage',
'user',
'Hello World!',
EditPage::AS_SUCCESS_NEW_ARTICLE,
'Hello World!'
],
[ 'expected article not being created if empty',
'EditPageTest_testCreatePage',
'user',
'',
EditPage::AS_BLANK_ARTICLE,
null
],
[ 'expected MediaWiki: page being created',
'MediaWiki:January',
'UTSysop',
'Not January',
EditPage::AS_SUCCESS_NEW_ARTICLE,
'Not January'
],
[ 'expected not-registered MediaWiki: page not being created if empty',
'MediaWiki:EditPageTest_testCreatePage',
'UTSysop',
'',
EditPage::AS_BLANK_ARTICLE,
null
],
[ 'expected registered MediaWiki: page being created even if empty',
'MediaWiki:January',
'UTSysop',
'',
EditPage::AS_SUCCESS_NEW_ARTICLE,
''
],
[ 'expected registered MediaWiki: page whose default content is empty'
. ' not being created if empty',
'MediaWiki:Ipb-default-expiry',
'UTSysop',
'',
EditPage::AS_BLANK_ARTICLE,
''
],
[ 'expected MediaWiki: page not being created if text equals default message',
'MediaWiki:January',
'UTSysop',
'January',
EditPage::AS_BLANK_ARTICLE,
null
],
[ 'expected empty article being created',
'EditPageTest_testCreatePage',
'user',
'',
EditPage::AS_SUCCESS_NEW_ARTICLE,
'',
true
],
];
}
/**
* @dataProvider provideCreatePages
* @covers \MediaWiki\EditPage\EditPage
*/
public function testCreatePage(
$desc, $pageTitle, $user, $editText, $expectedCode, $expectedText, $ignoreBlank = false
) {
$checkId = null;
$this->setTemporaryHook(
'PageSaveComplete',
static function (
WikiPage $page, UserIdentity $user, string $summary,
int $flags, RevisionRecord $revisionRecord, EditResult $editResult
) use ( &$checkId ) {
$checkId = $revisionRecord->getId();
// types/refs checked
}
);
$edit = [ 'wpTextbox1' => $editText ];
if ( $ignoreBlank ) {
$edit['wpIgnoreBlankArticle'] = 1;
}
$page = $this->assertEdit( $pageTitle, null, $user, $edit, $expectedCode, $expectedText, $desc );
if ( $expectedCode != EditPage::AS_BLANK_ARTICLE ) {
$latest = $page->getLatest();
$this->deletePage( $page );
$this->assertGreaterThan( 0, $latest, "Page revision ID updated in object" );
$this->assertEquals( $latest, $checkId, "Revision in Status for hook" );
}
}
/**
* @dataProvider provideCreatePages
* @covers \MediaWiki\EditPage\EditPage
*/
public function testCreatePageTrx(
$desc, $pageTitle, $user, $editText, $expectedCode, $expectedText, $ignoreBlank = false
) {
$checkIds = [];
$this->setTemporaryHook(
'PageSaveComplete',
static function (
WikiPage $page, UserIdentity $user, string $summary,
int $flags, RevisionRecord $revisionRecord, EditResult $editResult
) use ( &$checkIds ) {
$checkIds[] = $revisionRecord->getId();
// types/refs checked
}
);
$this->getDb()->begin( __METHOD__ );
$edit = [ 'wpTextbox1' => $editText ];
if ( $ignoreBlank ) {
$edit['wpIgnoreBlankArticle'] = 1;
}
$page = $this->assertEdit(
$pageTitle, null, $user, $edit, $expectedCode, $expectedText, $desc );
$pageTitle2 = (string)$pageTitle . '/x';
$page2 = $this->assertEdit(
$pageTitle2, null, $user, $edit, $expectedCode, $expectedText, $desc );
$this->getDb()->commit( __METHOD__ );
$this->assertSame( 0, DeferredUpdates::pendingUpdatesCount(), 'No deferred updates' );
if ( $expectedCode != EditPage::AS_BLANK_ARTICLE ) {
$latest = $page->getLatest();
$this->deletePage( $page );
$this->assertGreaterThan( 0, $latest, "Page #1 revision ID updated in object" );
$this->assertEquals( $latest, $checkIds[0], "Revision #1 in Status for hook" );
$latest2 = $page2->getLatest();
$this->deletePage( $page2 );
$this->assertGreaterThan( 0, $latest2, "Page #2 revision ID updated in object" );
$this->assertEquals( $latest2, $checkIds[1], "Revision #2 in Status for hook" );
}
}
/**
* @covers \MediaWiki\EditPage\EditPage
*/
public function testUpdatePage() {
$checkIds = [];
$this->setTemporaryHook(
'PageSaveComplete',
static function (
WikiPage $page, UserIdentity $user, string $summary,
int $flags, RevisionRecord $revisionRecord, EditResult $editResult
) use ( &$checkIds ) {
$checkIds[] = $revisionRecord->getId();
// types/refs checked
}
);
$text = "one";
$edit = [
'wpTextbox1' => $text,
'wpSummary' => 'first update',
];
$page = $this->assertEdit( 'EditPageTest_testUpdatePage', "zero", 'user', $edit,
EditPage::AS_SUCCESS_UPDATE, $text,
"expected successful update with given text" );
$this->assertGreaterThan( 0, $checkIds[0], "First event rev ID set" );
$this->forceRevisionDate( $page, '20120101000000' );
$text = "two";
$edit = [
'wpTextbox1' => $text,
'wpSummary' => 'second update',
];
$this->assertEdit( 'EditPageTest_testUpdatePage', null, 'user', $edit,
EditPage::AS_SUCCESS_UPDATE, $text,
"expected successful update with given text" );
$this->assertGreaterThan( 0, $checkIds[1], "Second edit hook rev ID set" );
$this->assertGreaterThan( $checkIds[0], $checkIds[1], "Second event rev ID is higher" );
}
/**
* @covers \MediaWiki\EditPage\EditPage
*/
public function testUpdateNoMinor() {
// Test that page creation can never be minor
$edit = [
'wpTextbox1' => 'testing',
'wpSummary' => 'first update',
'wpMinoredit' => 'minor'
];
$page = $this->assertEdit( 'EditPageTest_testUpdateNoMinor', null, 'user', $edit,
EditPage::AS_SUCCESS_NEW_ARTICLE, 'testing', "expected successful update" );
$this->assertFalse(
$page->getRevisionRecord()->isMinor(),
'page creation should not be minor'
);
// Test that anons can't make an update minor
$this->forceRevisionDate( $page, '20120101000000' );
$edit = [
'wpTextbox1' => 'testing 2',
'wpSummary' => 'second update',
'wpMinoredit' => 'minor'
];
// Next assertion uses an anon editor, so disable temp accounts
$this->disableAutoCreateTempUser();
$page = $this->assertEdit( 'EditPageTest_testUpdateNoMinor', null, 'anon', $edit,
EditPage::AS_SUCCESS_UPDATE, 'testing 2', "expected successful update" );
$this->assertFalse(
$page->getRevisionRecord()->isMinor(),
'anon edit should not be minor'
);
// Test that users can make an update minor
$this->forceRevisionDate( $page, '20120102000000' );
$edit = [
'wpTextbox1' => 'testing 3',
'wpSummary' => 'third update',
'wpMinoredit' => 'minor'
];
$page = $this->assertEdit( 'EditPageTest_testUpdateNoMinor', null, 'user', $edit,
EditPage::AS_SUCCESS_UPDATE, 'testing 3', "expected successful update" );
$this->assertTrue(
$page->getRevisionRecord()->isMinor(),
'users can make edits minor'
);
}
/**
* @covers \MediaWiki\EditPage\EditPage
*/
public function testUpdatePageTrx() {
$text = "one";
$edit = [
'wpTextbox1' => $text,
'wpSummary' => 'first update',
];
$page = $this->assertEdit( 'EditPageTest_testTrxUpdatePage', "zero", 'user', $edit,
EditPage::AS_SUCCESS_UPDATE, $text,
"expected successful update with given text" );
$this->forceRevisionDate( $page, '20120101000000' );
$checkIds = [];
$this->setTemporaryHook(
'PageSaveComplete',
static function (
WikiPage $page, UserIdentity $user, string $summary,
int $flags, RevisionRecord $revisionRecord, EditResult $editResult
) use ( &$checkIds ) {
$checkIds[] = $revisionRecord->getId();
// types/refs checked
}
);
$this->getDb()->begin( __METHOD__ );
$text = "two";
$edit = [
'wpTextbox1' => $text,
'wpSummary' => 'second update',
];
$this->assertEdit( 'EditPageTest_testTrxUpdatePage', null, 'user', $edit,
EditPage::AS_SUCCESS_UPDATE, $text,
"expected successful update with given text" );
$text = "three";
$edit = [
'wpTextbox1' => $text,
'wpSummary' => 'third update',
];
$this->assertEdit( 'EditPageTest_testTrxUpdatePage', null, 'user', $edit,
EditPage::AS_SUCCESS_UPDATE, $text,
"expected successful update with given text" );
$this->getDb()->commit( __METHOD__ );
$this->assertGreaterThan( 0, $checkIds[0], "First event rev ID set" );
$this->assertGreaterThan( 0, $checkIds[1], "Second edit hook rev ID set" );
$this->assertGreaterThan( $checkIds[0], $checkIds[1], "Second event rev ID is higher" );
}
public static function provideSectionEdit() {
$title = 'EditPageTest_testSectionEdit';
$title2 = Title::newFromText( __FUNCTION__ );
$title2->setContentModel( CONTENT_MODEL_CSS );
$text = 'Intro
== one ==
first section.
== two ==
second section.
';
$sectionOne = '== one ==
hello
';
$newSection = '== new section ==
hello
';
$textWithNewSectionOne = preg_replace(
'/== one ==.*== two ==/ms',
"$sectionOne\n== two ==", $text
);
$textWithNewSectionAdded = "$text\n$newSection";
return [
[ # 0
$title,
$text,
'',
'hello',
'replace all',
'hello'
],
[ # 1
$title,
$text,
'1',
$sectionOne,
'replace first section',
$textWithNewSectionOne,
],
[ # 2
$title,
$text,
'new',
'hello',
'new section',
$textWithNewSectionAdded,
],
[ # 3 Section edit not supported
$title2,
$text,
'1',
'hello',
'',
'',
],
];
}
/**
* @dataProvider provideSectionEdit
* @covers \MediaWiki\EditPage\EditPage
*/
public function testSectionEdit( $title, $base, $section, $text, $summary, $expected ) {
$edit = [
'wpTextbox1' => $text,
'wpSummary' => $summary,
'wpSection' => $section,
];
$msg = "expected successful update of section";
$result = EditPage::AS_SUCCESS_UPDATE;
if ( $title instanceof Title ) {
$result = null;
$this->expectException( ErrorPageError::class );
}
$this->assertEdit( $title, $base, 'user', $edit, $result, $expected, $msg );
}
public static function provideConflictDetection() {
yield 'no conflict detected' => [
'Adam',
[
'wpEdittime' => 2, // use the second edit's time
'editRevId' => 2, // use the second edit's revision ID
],
EditPage::AS_SUCCESS_UPDATE,
'successful update expected'
];
yield 'conflict detected based on wpEdittime' => [
'Adam',
[
'wpEdittime' => 1, // use the first edit's time
],
EditPage::AS_CONFLICT_DETECTED,
'conflict expected'
];
yield 'conflict detected based on editRevId' => [
'Adam',
[
'editRevId' => 1, // use the first edit's revision ID
],
EditPage::AS_CONFLICT_DETECTED,
'conflict expected'
];
yield 'conflict based on wpEdittime ignored for same user' => [
'Berta',
[
'wpEdittime' => 1, // use the first edit's time
],
EditPage::AS_SUCCESS_UPDATE,
'successful update expected'
];
yield 'conflict detected based on editRevId even for same user' => [
'Berta',
[
'editRevId' => 1, // use the first edit's revision ID
],
EditPage::AS_CONFLICT_DETECTED,
'conflict expected'
];
}
/**
* @dataProvider provideConflictDetection
* @covers \MediaWiki\EditPage\EditPage
*/
public function testConflictDetection( $editUser, $newEdit, $expectedCode, $message ) {
// create page
$ns = $this->getDefaultWikitextNS();
$title = Title::newFromText( __METHOD__, $ns );
$wikiPageFactory = $this->getServiceContainer()->getWikiPageFactory();
$page = $wikiPageFactory->newFromTitle( $title );
if ( $page->exists() ) {
$this->deletePage( $page, "clean slate for testing" );
}
$elmosEdit['wpTextbox1'] = 'Elmo\'s text';
$bertasEdit['wpTextbox1'] = 'Berta\'s text';
$newEdit['wpTextbox1'] = 'new text';
$elmosEdit['wpSummary'] = 'Elmo\'s edit';
$bertasEdit['wpSummary'] = 'Bertas\'s edit';
$newEdit['wpSummary'] ??= 'new edit';
// first edit: Elmo
$page = $this->assertEdit( __METHOD__, null, 'Elmo', $elmosEdit,
EditPage::AS_SUCCESS_NEW_ARTICLE, null, 'expected successful creation' );
$this->forceRevisionDate( $page, '20120101000000' );
$rev1 = $page->getRevisionRecord();
// second edit: Berta
$page = $this->assertEdit( __METHOD__, null, 'Berta', $bertasEdit,
EditPage::AS_SUCCESS_UPDATE, null, 'expected successful update' );
$this->forceRevisionDate( $page, '20120101111111' );
$rev2 = $page->getRevisionRecord();
if ( !empty( $newEdit['editRevId'] ) ) {
$newEdit['editRevId'] = $newEdit['editRevId'] === 1 ? $rev1->getId() : $rev2->getId();
}
if ( !empty( $newEdit['wpEdittime'] ) ) {
$newEdit['wpEdittime'] =
$newEdit['wpEdittime'] === 1 ? $rev1->getTimestamp() : $rev2->getTimestamp();
}
// third edit
$this->assertEdit( __METHOD__, null, $editUser, $newEdit,
$expectedCode, null, $message );
}
public static function provideAutoMerge() {
$tests = [];
$tests[] = [ # 0: plain conflict
"Elmo", # base edit user
"one\n\ntwo\n\nthree\n",
[ # adam's edit
'wpTextbox1' => "ONE\n\ntwo\n\nthree\n",
],
[ # berta's edit
'wpTextbox1' => "(one)\n\ntwo\n\nthree\n",
],
EditPage::AS_CONFLICT_DETECTED, # expected code
"ONE\n\ntwo\n\nthree\n", # expected text
'expected edit conflict', # message
];
$tests[] = [ # 1: successful merge
"Elmo", # base edit user
"one\n\ntwo\n\nthree\n",
[ # adam's edit
'wpStarttime' => 1,
'wpTextbox1' => "ONE\n\ntwo\n\nthree\n",
],
[ # berta's edit
'wpStarttime' => 2,
'wpTextbox1' => "one\n\ntwo\n\nTHREE\n",
],
EditPage::AS_SUCCESS_UPDATE, # expected code
"ONE\n\ntwo\n\nTHREE\n", # expected text
'expected automatic merge', # message
];
$text = "Intro\n\n";
$text .= "== first section ==\n\n";
$text .= "one\n\ntwo\n\nthree\n\n";
$text .= "== second section ==\n\n";
$text .= "four\n\nfive\n\nsix\n\n";
// extract the first section.
$section = preg_replace( '/.*(== first section ==.*)== second section ==.*/sm', '$1', $text );
// generate expected text after merge
$expected = str_replace( 'one', 'ONE', str_replace( 'three', 'THREE', $text ) );
$tests[] = [ # 2: merge in section
"Elmo", # base edit user
$text,
[ # adam's edit
'wpTextbox1' => str_replace( 'one', 'ONE', $section ),
'wpSection' => '1'
],
[ # berta's edit
'wpTextbox1' => str_replace( 'three', 'THREE', $section ),
'wpSection' => '1'
],
EditPage::AS_SUCCESS_UPDATE, # expected code
$expected, # expected text
'expected automatic section merge', # message
];
// see whether it makes a difference who did the base edit
$testsWithAdam = array_map( static function ( $test ) {
$test[0] = 'Adam'; // change base edit user
return $test;
}, $tests );
$testsWithBerta = array_map( static function ( $test ) {
$test[0] = 'Berta'; // change base edit user
return $test;
}, $tests );
return array_merge( $tests, $testsWithAdam, $testsWithBerta );
}
/**
* @dataProvider provideAutoMerge
* @covers \MediaWiki\EditPage\EditPage
*/
public function testAutoMerge( $baseUser, $text, $adamsEdit, $bertasEdit,
$expectedCode, $expectedText, $message = null
) {
$this->markTestSkippedIfNoDiff3();
// create page
$ns = $this->getDefaultWikitextNS();
$title = Title::makeTitle( $ns, 'EditPageTest_testAutoMerge' );
$wikiPageFactory = $this->getServiceContainer()->getWikiPageFactory();
$page = $wikiPageFactory->newFromTitle( $title );
if ( $page->exists() ) {
$this->deletePage( $page, "clean slate for testing" );
}
$baseEdit = [
'wpTextbox1' => $text,
];
$page = $this->assertEdit( 'EditPageTest_testAutoMerge', null,
$baseUser, $baseEdit, null, null, __METHOD__ );
$this->forceRevisionDate( $page, '20120101000000' );
$edittime = $page->getTimestamp();
$revId = $page->getLatest();
$adamsEdit['wpSummary'] = 'Adam\'s edit';
$bertasEdit['wpSummary'] = 'Bertas\'s edit';
$adamsEdit['wpEdittime'] = $edittime;
$bertasEdit['wpEdittime'] = $edittime;
$adamsEdit['editRevId'] = $revId;
$bertasEdit['editRevId'] = $revId;
// first edit
$this->assertEdit( 'EditPageTest_testAutoMerge', null, 'Adam', $adamsEdit,
EditPage::AS_SUCCESS_UPDATE, null, "expected successful update" );
// second edit
$this->assertEdit( 'EditPageTest_testAutoMerge', null, 'Berta', $bertasEdit,
$expectedCode, $expectedText, $message );
}
/**
* @depends testAutoMerge
* @covers \MediaWiki\EditPage\EditPage
*/
public function testCheckDirectEditingDisallowed_forNonTextContent() {
$user = self::$editUsers['user'];
$edit = [
'wpTextbox1' => serialize( 'non-text content' ),
'wpEditToken' => $user->getEditToken(),
'wpEdittime' => '',
'editRevId' => 0,
'wpStarttime' => wfTimestampNow(),
'wpUnicodeCheck' => EditPage::UNICODE_CHECK,
];
$this->expectException( MWException::class );
$this->expectExceptionMessage( 'This content model is not supported: testing' );
$this->doEditDummyNonTextPage( $edit );
}
/** @covers \MediaWiki\EditPage\EditPage */
public function testShouldPreventChangingContentModelWhenUserCannotChangeModelForTitle() {
$this->setTemporaryHook( 'getUserPermissionsErrors',
static function ( Title $page, $user, $action, &$result ) {
if ( $action === 'editcontentmodel' &&
$page->getContentModel() === CONTENT_MODEL_WIKITEXT
) {
$result = false;
return false;
}
} );
$user = self::$editUsers['user'];
$status = $this->doEditDummyNonTextPage( [
'wpTextbox1' => 'some text',
'wpEditToken' => $user->getEditToken(),
'wpEdittime' => '',
'editRevId' => 0,
'wpStarttime' => wfTimestampNow(),
'wpUnicodeCheck' => EditPage::UNICODE_CHECK,
'model' => CONTENT_MODEL_WIKITEXT,
'format' => CONTENT_FORMAT_WIKITEXT,
] );
$this->assertStatusNotOK( $status );
$this->assertStatusValue( EditPage::AS_NO_CHANGE_CONTENT_MODEL, $status );
}
/** @covers \MediaWiki\EditPage\EditPage */
public function testShouldPreventChangingContentModelWhenUserCannotEditTargetTitle() {
$this->setTemporaryHook( 'getUserPermissionsErrors',
static function ( Title $page, $user, $action, &$result ) {
if ( $action === 'edit' && $page->getContentModel() === CONTENT_MODEL_WIKITEXT ) {
$result = false;
return false;
}
} );
$user = $this->getTestUser()->getUser();
$status = $this->doEditDummyNonTextPage( [
'wpTextbox1' => 'some text',
'wpEditToken' => $user->getEditToken(),
'wpEdittime' => '',
'editRevId' => 0,
'wpStarttime' => wfTimestampNow(),
'wpUnicodeCheck' => EditPage::UNICODE_CHECK,
'model' => CONTENT_MODEL_WIKITEXT,
'format' => CONTENT_FORMAT_WIKITEXT,
] );
$this->assertStatusNotOK( $status );
$this->assertStatusValue( EditPage::AS_NO_CHANGE_CONTENT_MODEL, $status );
}
private function doEditDummyNonTextPage( array $edit ): Status {
$title = Title::newFromText( 'Dummy:NonTextPageForEditPage' );
$article = new Article( $title );
$article->getContext()->setTitle( $title );
$ep = new EditPage( $article );
$ep->setContextTitle( $title );
$req = new FauxRequest( $edit, true );
$ep->importFormData( $req );
return $ep->attemptSave( $result );
}
/**
* The watchlist expiry field should select the entered value on preview, rather than the
* calculated number of days till the expiry (as it shows on edit).
* @covers \MediaWiki\EditPage\EditPage::getCheckboxesDefinition()
* @dataProvider provideWatchlistExpiry()
*/
public function testWatchlistExpiry( $existingExpiry, $postVal, $selected, $options ) {
// Set up config and fake current time.
$this->overrideConfigValue( MainConfigNames::WatchlistExpiry, true );
MWTimestamp::setFakeTime( '20200505120000' );
$user = $this->getTestUser()->getUser();
$this->assertTrue( $user->isRegistered() );
// Create the EditPage.
$title = Title::newFromText( __METHOD__ );
$context = new RequestContext();
$context->setUser( $user );
$context->setTitle( $title );
$article = new Article( $title );
$article->setContext( $context );
$ep = new EditPage( $article );
$this->getServiceContainer()->getWatchlistManager()
->setWatch( (bool)$existingExpiry, $user, $title, $existingExpiry );
// Send the request.
$req = new FauxRequest( [], true );
$context->setRequest( $req );
$req->getSession()->setUser( $user );
$ep->importFormData( $req );
$def = $ep->getCheckboxesDefinition( [ 'watch' => true, 'wpWatchlistExpiry' => $postVal ] )['wpWatchlistExpiry'];
// Test selected and available options.
$this->assertSame( $selected, $def['default'] );
$dropdownOptions = [];
foreach ( $def['options'] as $option ) {
// Reformat dropdown options for easier test comparison.
$dropdownOptions[] = $option['data'];
}
$this->assertSame( $options, $dropdownOptions );
}
public static function provideWatchlistExpiry() {
$standardOptions = [ 'infinite', '1 week', '1 month', '3 months', '6 months', '1 year' ];
return [
'not watched, request nothing' => [
'existingExpiry' => '',
'postVal' => '',
'selected' => 'infinite',
'options' => $standardOptions,
],
'not watched' => [
'existingExpiry' => '',
'postVal' => '1 month',
'result' => '1 month',
'options' => $standardOptions,
],
'watched with current selected' => [
'existingExpiry' => '2020-05-05T12:00:01Z',
'postVal' => '2020-05-05T12:00:01Z',
'result' => '2020-05-05T12:00:01Z',
'options' => array_merge( [ '2020-05-05T12:00:01Z' ], $standardOptions ),
],
'watched with 1 week selected' => [
'existingExpiry' => '2020-05-05T12:00:02Z',
'postVal' => '1 week',
'result' => '1 week',
'options' => array_merge( [ '2020-05-05T12:00:02Z' ], $standardOptions ),
],
];
}
/**
* T277204
* @covers \MediaWiki\EditPage\EditPage
*/
public function testFalseyEditRevId() {
$elmosEdit['wpTextbox1'] = 'Elmo\'s text';
$bertasEdit['wpTextbox1'] = 'Berta\'s text';
$elmosEdit['wpSummary'] = 'Elmo\'s edit';
$bertasEdit['wpSummary'] = 'Bertas\'s edit';
$bertasEdit['editRevId'] = 0;
$this->assertEdit( __METHOD__,
null, 'Elmo', $elmosEdit,
EditPage::AS_SUCCESS_NEW_ARTICLE, null, 'expected successful creation' );
// A successful update would probably be OK too. The important thing is
// that it doesn't throw an exception.
$this->assertEdit( __METHOD__, null, 'Berta', $bertasEdit,
EditPage::AS_CONFLICT_DETECTED, null, 'expected successful update' );
}
}
PK ! J Q Q $ editpage/EditPageConstraintsTest.phpnu Iw getServiceContainer()->getContentLanguage();
$this->overrideConfigValues( [
MainConfigNames::ExtraNamespaces => [
12312 => 'Dummy',
12313 => 'Dummy_talk',
],
MainConfigNames::NamespaceContentModels => [ 12312 => 'testing' ],
MainConfigNames::LanguageCode => $contLang->getCode(),
] );
$this->mergeMwGlobalArrayValue(
'wgContentHandlers',
[ 'testing' => 'DummyContentHandlerForTesting' ]
);
}
/**
* Based on method in EditPageTest
* Performs an edit and checks the result matches the expected failure code
*
* @param string|Title $title The title of the page to edit
* @param string|null $baseText Some text to create the page with before attempting the edit.
* @param User|null $user The user to perform the edit as.
* @param array $edit An array of request parameters used to define the edit to perform.
* Some well known fields are:
* * wpTextbox1: the text to submit
* * wpSummary: the edit summary
* * wpEditToken: the edit token (will be inserted if not provided)
* * wpEdittime: timestamp of the edit's base revision (will be inserted
* if not provided)
* * editRevId: revision ID of the edit's base revision (optional)
* * wpStarttime: timestamp when the edit started (will be inserted if not provided)
* * wpSectionTitle: the section to edit
* * wpMinorEdit: mark as minor edit
* * wpWatchthis: whether to watch the page
* @param int $expectedCode The expected result code (EditPage::AS_XXX constants).
* @param string $message Message to show along with any error message.
*
* @return WikiPage The page that was just edited, useful for getting the edit's rev_id, etc.
*/
protected function assertEdit(
$title,
$baseText,
?User $user,
array $edit,
$expectedCode,
$message
) {
if ( is_string( $title ) ) {
$ns = $this->getDefaultWikitextNS();
$title = Title::newFromText( $title, $ns );
}
$this->assertNotNull( $title );
$wikiPageFactory = $this->getServiceContainer()->getWikiPageFactory();
$page = $wikiPageFactory->newFromTitle( $title );
$user ??= $this->getTestUser()->getUser();
if ( $baseText !== null ) {
$content = ContentHandler::makeContent( $baseText, $title );
$page->doUserEditContent( $content, $user, "base text for test" );
// Set the latest timestamp back a while
$dbw = $this->getDb();
$dbw->newUpdateQueryBuilder()
->update( 'revision' )
->set( [ 'rev_timestamp' => $dbw->timestamp( '20120101000000' ) ] )
->where( [ 'rev_id' => $page->getLatest() ] )
->execute();
$page->clear();
$content = $page->getContent();
$this->assertInstanceOf( TextContent::class, $content );
$currentText = $content->getText();
# EditPage rtrim() the user input, so we alter our expected text
# to reflect that.
$this->assertEquals(
rtrim( $baseText ),
rtrim( $currentText ),
'page should have the text specified'
);
}
if ( !isset( $edit['wpEditToken'] ) ) {
$edit['wpEditToken'] = $user->getEditToken();
}
if ( !isset( $edit['wpEdittime'] ) && !isset( $edit['editRevId'] ) ) {
$edit['wpEdittime'] = $page->exists() ? $page->getTimestamp() : '';
}
if ( !isset( $edit['wpStarttime'] ) ) {
$edit['wpStarttime'] = wfTimestampNow();
}
if ( !isset( $edit['wpUnicodeCheck'] ) ) {
$edit['wpUnicodeCheck'] = EditPage::UNICODE_CHECK;
}
$req = new FauxRequest( $edit, true ); // session ??
$context = new RequestContext();
$context->setRequest( $req );
$context->setTitle( $title );
$context->setUser( $user );
$article = new Article( $title );
$article->setContext( $context );
$ep = new EditPage( $article );
$ep->setContextTitle( $title );
$ep->importFormData( $req );
// this is where the edit happens!
$status = $ep->attemptSave( $result );
// check edit code
$this->assertSame(
$expectedCode,
$status->value,
"Expected result code mismatch. $message"
);
return $wikiPageFactory->newFromTitle( $title );
}
/** AccidentalRecreationConstraint integration */
public function testAccidentalRecreationConstraint() {
// Make sure it exists
$this->getExistingTestPage( 'AccidentalRecreationConstraintPage' );
// And now delete it, so that there is a deletion log
$page = $this->getNonexistingTestPage( 'AccidentalRecreationConstraintPage' );
$title = $page->getTitle();
// Set the time of the deletion to be a specific time, so we can be sure to start the
// edit before it. Since the constraint will query for the most recent timestamp,
// update *all* deletion logs for the page to the same timestamp (1 January 2020)
$dbw = $this->getDb();
$dbw->newUpdateQueryBuilder()
->update( 'logging' )
->set( [ 'log_timestamp' => $dbw->timestamp( '20200101000000' ) ] )
->where( [
'log_namespace' => $title->getNamespace(),
'log_title' => $title->getDBkey(),
'log_type' => 'delete',
'log_action' => 'delete',
] )
->caller( __METHOD__ )->execute();
$user = $this->getTestUser()->getUser();
$permissionManager = $this->getServiceContainer()->getPermissionManager();
// Needs edit rights to pass EditRightConstraint and reach AccidentalRecreationConstraint
$permissionManager->overrideUserRightsForTesting( $user, [ 'edit' ] );
// Started the edit on 1 January 2019, page was deleted on 1 January 2020
$edit = [
'wpTextbox1' => 'New content',
'wpStarttime' => '20190101000000'
];
$this->assertEdit(
$title,
null,
$user,
$edit,
EditPage::AS_ARTICLE_WAS_DELETED,
'expected AS_ARTICLE_WAS_DELETED update'
);
}
/** ExistingSectionEditConstraint integration */
public function testExistingSectionEditConstraint() {
// Require the summary
$this->mergeMwGlobalArrayValue(
'wgDefaultUserOptions',
[ 'forceeditsummary' => 1 ]
);
$page = $this->getExistingTestPage( 'ExistingSectionEditConstraint page does exist' );
$title = $page->getTitle();
$user = $this->getTestUser()->getUser();
$permissionManager = $this->getServiceContainer()->getPermissionManager();
// Needs edit rights to pass EditRightConstraint and reach NewSectionMissingSubjectConstraint
$permissionManager->overrideUserRightsForTesting( $user, [ 'edit' ] );
$edit = [
'wpTextbox1' => 'New content, different from base content',
'wpSummary' => 'SameAsAutoSummary',
'wpAutoSummary' => md5( 'SameAsAutoSummary' )
];
$this->assertEdit(
$title,
'Base content, different from new content',
$user,
$edit,
EditPage::AS_SUMMARY_NEEDED,
'expected AS_SUMMARY_NEEDED update'
);
}
/** ChangeTagsConstraint integration */
public function testChangeTagsConstraint() {
// Remove rights
$this->mergeMwGlobalArrayValue(
'wgRevokePermissions',
[ 'user' => [ 'applychangetags' => true ] ]
);
$edit = [
'wpTextbox1' => 'Text',
'wpChangeTags' => 'tag-name'
];
$this->assertEdit(
'EditPageTest_changeTagsConstraint',
null,
null,
$edit,
EditPage::AS_CHANGE_TAG_ERROR,
'expected AS_CHANGE_TAG_ERROR update'
);
}
/** ContentModelChangeConstraint integration */
public function testContentModelChangeConstraint() {
$user = $this->getTestUser()->getUser();
$permissionManager = $this->getServiceContainer()->getPermissionManager();
// Needs edit rights to pass EditRightConstraint and reach ContentModelChangeConstraint
$permissionManager->overrideUserRightsForTesting( $user, [ 'edit' ] );
$edit = [
'wpTextbox1' => 'New text goes here',
'wpSummary' => 'Summary',
'model' => CONTENT_MODEL_TEXT,
'format' => CONTENT_FORMAT_TEXT,
];
$title = Title::makeTitle( NS_MAIN, 'Example' );
$this->assertSame(
CONTENT_MODEL_WIKITEXT,
$title->getContentModel(),
'title should start as wikitext content model'
);
$this->assertEdit(
$title,
'Base text',
$user,
$edit,
EditPage::AS_NO_CHANGE_CONTENT_MODEL,
'expected AS_NO_CHANGE_CONTENT_MODEL update'
);
}
/** CreationPermissionConstraint integration */
public function testCreationPermissionConstraint() {
$page = $this->getNonexistingTestPage( 'CreationPermissionConstraint page does not exist' );
$title = $page->getTitle();
$user = $this->getTestUser()->getUser();
$permissionManager = $this->getServiceContainer()->getPermissionManager();
// Needs edit rights to pass EditRightConstraint and reach CreationPermissionConstraint
$permissionManager->overrideUserRightsForTesting( $user, [ 'edit' ] );
$edit = [
'wpTextbox1' => 'Page content',
'wpSummary' => 'Summary'
];
$this->assertEdit(
$title,
null,
$user,
$edit,
EditPage::AS_NO_CREATE_PERMISSION,
'expected AS_NO_CREATE_PERMISSION creation'
);
}
/** DefaultTextConstraint integration */
public function testDefaultTextConstraint() {
$page = $this->getNonexistingTestPage( 'DefaultTextConstraint page does not exist' );
$title = $page->getTitle();
$user = $this->getTestUser()->getUser();
$permissionManager = $this->getServiceContainer()->getPermissionManager();
// Needs edit and createpage rights to pass EditRightConstraint and CreationPermissionConstraint
$permissionManager->overrideUserRightsForTesting( $user, [ 'edit', 'createpage' ] );
$edit = [
'wpTextbox1' => '',
'wpSummary' => 'Summary'
];
$this->assertEdit(
$title,
null,
$user,
$edit,
EditPage::AS_BLANK_ARTICLE,
'expected AS_BLANK_ARTICLE creation'
);
}
/**
* EditFilterMergedContentHookConstraint integration
* @dataProvider provideTestEditFilterMergedContentHookConstraint
* @param bool $hookReturn
* @param ?int $statusValue
* @param bool $statusFatal
* @param int $expectedFailure
* @param string $expectedFailureStr
*/
public function testEditFilterMergedContentHookConstraint(
bool $hookReturn,
$statusValue,
bool $statusFatal,
int $expectedFailure,
string $expectedFailureStr
) {
$this->setTemporaryHook(
'EditFilterMergedContent',
static function ( $context, $content, $status, $summary, $user, $minorEdit )
use ( $hookReturn, $statusValue, $statusFatal )
{
if ( $statusValue !== null ) {
$status->value = $statusValue;
}
if ( $statusFatal ) {
$status->fatal( 'SomeErrorInTheHook' );
}
return $hookReturn;
}
);
$user = $this->getTestUser()->getUser();
$permissionManager = $this->getServiceContainer()->getPermissionManager();
// Needs edit and createpage rights to pass EditRightConstraint and CreationPermissionConstraint
$permissionManager->overrideUserRightsForTesting( $user, [ 'edit', 'createpage' ] );
$edit = [
'wpTextbox1' => 'Text',
'wpSummary' => 'Summary'
];
$this->assertEdit(
'EditPageTest_testEditFilterMergedContentHookConstraint',
null,
$user,
$edit,
$expectedFailure,
"expected $expectedFailureStr creation"
);
}
public static function provideTestEditFilterMergedContentHookConstraint() {
yield 'Hook returns false, status is good, no value set' => [
false, null, false, EditPage::AS_HOOK_ERROR_EXPECTED, 'AS_HOOK_ERROR_EXPECTED'
];
yield 'Hook returns false, status is good, value set' => [
false, 1234567, false, 1234567, 'custom value 1234567'
];
yield 'Hook returns false, status is not good' => [
false, null, true, EditPage::AS_HOOK_ERROR_EXPECTED, 'AS_HOOK_ERROR_EXPECTED'
];
yield 'Hook returns true, status is not ok' => [
true, null, true, EditPage::AS_HOOK_ERROR_EXPECTED, 'AS_HOOK_ERROR_EXPECTED'
];
}
/**
* EditRightConstraint integration
* @dataProvider provideTestEditRightConstraint
* @param bool $anon
* @param int $expectedErrorCode
*/
public function testEditRightConstraint( $anon, $expectedErrorCode ) {
if ( $anon ) {
$this->disableAutoCreateTempUser();
$user = $this->getServiceContainer()->getUserFactory()->newAnonymous( '127.0.0.1' );
} else {
$user = $this->getTestUser()->getUser();
}
$permissionManager = $this->getServiceContainer()->getPermissionManager();
$permissionManager->overrideUserRightsForTesting( $user, [] );
$edit = [
'wpTextbox1' => 'Page content',
'wpSummary' => 'Summary'
];
$this->assertEdit(
'EditPageTest_noEditRight',
'base text',
$user,
$edit,
$expectedErrorCode,
'expected AS_READ_ONLY_PAGE_* update'
);
}
public static function provideTestEditRightConstraint() {
yield 'Anonymous user' => [ true, EditPage::AS_READ_ONLY_PAGE_ANON ];
yield 'Registered user' => [ false, EditPage::AS_READ_ONLY_PAGE_LOGGED ];
}
/**
* ImageRedirectConstraint integration
* @dataProvider provideTestImageRedirectConstraint
* @param bool $anon
* @param int $expectedErrorCode
*/
public function testImageRedirectConstraint( $anon, $expectedErrorCode ) {
if ( $anon ) {
$this->disableAutoCreateTempUser();
$user = $this->getServiceContainer()->getUserFactory()->newAnonymous( '127.0.0.1' );
} else {
$user = $this->getTestUser()->getUser();
}
$permissionManager = $this->getServiceContainer()->getPermissionManager();
// Needs edit rights to pass EditRightConstraint and reach ImageRedirectConstraint
$permissionManager->overrideUserRightsForTesting( $user, [ 'edit' ] );
$edit = [
'wpTextbox1' => '#REDIRECT [[File:Example other file.jpg]]',
'wpSummary' => 'Summary'
];
$title = Title::makeTitle( NS_FILE, 'Example.jpg' );
$this->assertEdit(
$title,
null,
$user,
$edit,
$expectedErrorCode,
'expected AS_IMAGE_REDIRECT_* update'
);
}
public static function provideTestImageRedirectConstraint() {
yield 'Anonymous user' => [ true, EditPage::AS_IMAGE_REDIRECT_ANON ];
yield 'Registered user' => [ false, EditPage::AS_IMAGE_REDIRECT_LOGGED ];
}
/** MissingCommentConstraint integration */
public function testMissingCommentConstraint() {
$page = $this->getExistingTestPage( 'MissingCommentConstraint page does exist' );
$title = $page->getTitle();
$user = $this->getTestUser()->getUser();
$permissionManager = $this->getServiceContainer()->getPermissionManager();
// Needs edit rights to pass EditRightConstraint and reach MissingCommentConstraint
$permissionManager->overrideUserRightsForTesting( $user, [ 'edit' ] );
$edit = [
'wpTextbox1' => '',
'wpSection' => 'new',
'wpSummary' => 'Summary'
];
$this->assertEdit(
$title,
null,
$user,
$edit,
EditPage::AS_TEXTBOX_EMPTY,
'expected AS_TEXTBOX_EMPTY update'
);
}
/** NewSectionMissingSubjectConstraint integration */
public function testNewSectionMissingSubjectConstraint() {
// Require the summary
$this->mergeMwGlobalArrayValue(
'wgDefaultUserOptions',
[ 'forceeditsummary' => 1 ]
);
$page = $this->getExistingTestPage( 'NewSectionMissingSubjectConstraint page does exist' );
$title = $page->getTitle();
$user = $this->getTestUser()->getUser();
$permissionManager = $this->getServiceContainer()->getPermissionManager();
// Needs edit rights to pass EditRightConstraint and reach NewSectionMissingSubjectConstraint
$permissionManager->overrideUserRightsForTesting( $user, [ 'edit' ] );
$edit = [
'wpTextbox1' => 'Comment',
'wpSection' => 'new',
'wpSummary' => ''
];
$this->assertEdit(
$title,
null,
$user,
$edit,
EditPage::AS_SUMMARY_NEEDED,
'expected AS_SUMMARY_NEEDED update'
);
}
/** PageSizeConstraint integration */
public function testPageSizeConstraintBeforeMerge() {
// Max size: 1 kibibyte
$this->overrideConfigValue( MainConfigNames::MaxArticleSize, 1 );
$edit = [
'wpTextbox1' => str_repeat( 'text', 1000 )
];
$this->assertEdit(
'EditPageTest_pageSizeConstraintBeforeMerge',
null,
null,
$edit,
EditPage::AS_CONTENT_TOO_BIG,
'expected AS_CONTENT_TOO_BIG update'
);
}
/** PageSizeConstraint integration */
public function testPageSizeConstraintAfterMerge() {
// Max size: 1 kibibyte
$this->overrideConfigValue( MainConfigNames::MaxArticleSize, 1 );
$edit = [
'wpSection' => 'new',
'wpTextbox1' => str_repeat( 'b', 600 )
];
$this->assertEdit(
'EditPageTest_pageSizeConstraintAfterMerge',
str_repeat( 'a', 600 ),
null,
$edit,
EditPage::AS_MAX_ARTICLE_SIZE_EXCEEDED,
'expected AS_MAX_ARTICLE_SIZE_EXCEEDED update'
);
}
/** ReadOnlyConstraint integration */
public function testReadOnlyConstraint() {
$readOnlyMode = $this->createMock( ReadOnlyMode::class );
$readOnlyMode->method( 'isReadOnly' )->willReturn( true );
$this->setService( 'ReadOnlyMode', $readOnlyMode );
$edit = [
'wpTextbox1' => 'Text goes here'
];
$this->assertEdit(
'EditPageTest_readOnlyConstraint',
null,
null,
$edit,
EditPage::AS_READ_ONLY_PAGE,
'expected AS_READ_ONLY_PAGE update'
);
}
/** SelfRedirectConstraint integration */
public function testSelfRedirectConstraint() {
// Use a page that does not exist to be sure that it is not already a self redirect
$page = $this->getNonexistingTestPage( 'SelfRedirectConstraint page does not exist' );
$title = $page->getTitle();
$edit = [
'wpTextbox1' => '#REDIRECT [[SelfRedirectConstraint page does not exist]]',
'wpSummary' => 'Redirect to self'
];
$this->assertEdit(
$title,
'zero',
null,
$edit,
EditPage::AS_SELF_REDIRECT,
'expected AS_SELF_REDIRECT update'
);
}
/** SimpleAntiSpamConstraint integration */
public function testSimpleAntiSpamConstraint() {
$edit = [
'wpTextbox1' => 'one',
'wpSummary' => 'first update',
'wpAntispam' => 'tatata'
];
$this->assertEdit(
'EditPageTest_testUpdatePageSpamError',
'zero',
null,
$edit,
EditPage::AS_SPAM_ERROR,
'expected AS_SPAM_ERROR update'
);
}
/** SpamRegexConstraint integration */
public function testSpamRegexConstraint() {
$spamChecker = $this->createMock( SpamChecker::class );
$spamChecker->method( 'checkContent' )
->willReturnArgument( 0 );
$spamChecker->method( 'checkSummary' )
->willReturnArgument( 0 );
$this->setService( 'SpamChecker', $spamChecker );
$edit = [
'wpTextbox1' => 'two',
'wpSummary' => 'spam summary'
];
$this->assertEdit(
'EditPageTest_testUpdatePageSpamRegexError',
'zero',
null,
$edit,
EditPage::AS_SPAM_ERROR,
'expected AS_SPAM_ERROR update'
);
}
/** UserBlockConstraint integration */
public function testUserBlockConstraint() {
$user = $this->createMock( User::class );
$user->method( 'getName' )->willReturn( 'NameGoesHere' );
$user->method( 'getId' )->willReturn( 12345 );
$permissionManager = $this->createMock( PermissionManager::class );
// Needs edit rights to pass EditRightConstraint and reach UserBlockConstraint
$permissionManager->method( 'userHasRight' )->willReturn( true );
$permissionManager->method( 'userCan' )->willReturn( true );
// Not worried about the specifics of the method call, those are tested in
// the UserBlockConstraintTest
$permissionManager->method( 'isBlockedFrom' )->willReturn( true );
$this->setService( 'PermissionManager', $permissionManager );
$edit = [
'wpTextbox1' => 'Page content',
'wpSummary' => 'Summary'
];
$this->assertEdit(
'EditPageTest_userBlocked',
'base text',
null,
$edit,
EditPage::AS_BLOCKED_PAGE_FOR_USER,
'expected AS_BLOCKED_PAGE_FOR_USER update'
);
}
/** UserRateLimitConstraint integration */
public function testUserRateLimitConstraint() {
$this->setTemporaryHook(
'PingLimiter',
static function ( $user, $action, &$result, $incrBy ) {
// Always fail
$result = true;
return false;
}
);
$edit = [
'wpTextbox1' => 'Text goes here'
];
$this->assertEdit(
'EditPageTest_userRateLimitConstraint',
null,
null,
$edit,
EditPage::AS_RATE_LIMITED,
'expected AS_RATE_LIMITED update'
);
}
}
PK ! {- $ editpage/IntroMessageBuilderTest.phpnu Iw getServiceContainer();
$config = new HashConfig( [
MainConfigNames::AllowUserCss => true,
MainConfigNames::AllowUserJs => true,
] );
$repoGroup = $this->createMock( RepoGroup::class );
$repoGroup
->method( 'findFile' )
->willReturnCallback( function ( ProperPageIdentity $title ) {
if ( $title->getDBkey() === 'Shared.png' || $title->getDBkey() === 'Shared-with-desc.png' ) {
$file = $this->createMock( File::class );
$file->method( 'isLocal' )->willReturn( false );
$file->method( 'getDescriptionUrl' )->willReturn( 'https://example.com/' );
$repo = $this->createMock( FileRepo::class );
$repo->method( 'getDisplayName' )->willReturn( '' );
$file->method( 'getRepo' )->willReturn( $repo );
return $file;
}
return null;
} );
$tempUserCreator = $this->createMock( TempUserCreator::class );
$tempUserCreator
->method( 'isAutoCreateAction' )
->willReturn( false );
$userFactory = $this->createMock( UserFactory::class );
$userFactory
->method( 'newFromName' )
->willReturnCallback( static function ( $name ) {
$user = new User;
$user->load(); // from 'defaults'
$user->mName = $name;
$user->mId = in_array( $name, [ 'Alice', 'Bob' ] ) ? 1 : 0;
$user->mDataLoaded = true;
return $user;
} );
$this->introMessageBuilder = new IntroMessageBuilder(
$config,
$services->getLinkRenderer(),
$services->getPermissionManager(),
$services->getUserNameUtils(),
$tempUserCreator,
$userFactory,
$services->getRestrictionStore(),
$services->getDatabaseBlockStore(),
$services->getReadOnlyMode(),
$services->getSpecialPageFactory(),
$repoGroup,
$services->getNamespaceInfo(),
$services->getSkinFactory(),
$services->getConnectionProvider(),
$services->getUrlUtils()
);
}
public static function provideCases() {
// title, oldid, user, editIntro, pages, expectedMessage, expectedWrap
$errorClass = 'cdx-message--error';
$warningClass = 'cdx-message--warning';
yield 'Main namespace has no default message' =>
[ 'Hello', null, 'Alice', null, [ 'Hello' => '' ],
[], null ];
yield 'Logged-out warning' =>
[ 'Hello', null, null, null, [ 'Hello' => '' ],
[ "anoneditwarning" ], $warningClass ];
// Code and message editing
yield 'User JavaScript requires alert as well as code-specific message' =>
[ 'User:Bob/common.js', null, 'Alice', null, [ 'User:Bob/common.js' => '' ],
[ "userjsdangerous", "editpage-code-message" ], $errorClass ];
yield 'Inform users that their JS is public and suggest guidelines' =>
[ 'User:Bob/common.js', null, 'Bob', null, [ 'User:Bob/common.js' => '' ],
[ "userjsispublic", "userjsdangerous", "editpage-code-message", "userjsyoucanpreview" ], $errorClass ];
yield 'MediaWiki: namespace JSON requires alert' =>
[ 'MediaWiki:Map.json', null, 'Alice', null, [],
[ "editinginterface", "newarticletext" ], $errorClass ];
yield 'MediaWiki: namespace message requires alert' =>
[ 'MediaWiki:Does-not-exist-asdfasdf', null, 'Alice', null, [],
[ "editinginterface", "newarticletext" ], $errorClass ];
yield 'Translateable MediaWiki: namespace message links to Translatewiki' =>
[ 'MediaWiki:View', null, 'Alice', null, [],
[ "editinginterface", "translateinterface", "newarticletext" ], $errorClass ];
// Files
yield 'Neither shared not local file exists' =>
[ 'File:Missing.png', null, 'Alice', null, [],
[ "newarticletext" ], "mw-newarticletext" ];
yield 'Shared file exists, local description does not exist' =>
[ 'File:Shared.png', null, 'Alice', null, [],
[ "sharedupload-desc-create", "newarticletext" ], "mw-sharedupload-desc-create" ];
yield 'Shared file exists, local description exists' =>
[ 'File:Shared-with-desc.png', null, 'Alice', null, [ 'File:Shared-with-desc.png' => 'Test' ],
[ "sharedupload-desc-edit" ], "mw-sharedupload-desc-edit" ];
// Users
yield 'User does not exist' =>
[ 'User:Foo', null, 'Alice', null, [],
[ "userpage-userdoesnotexist", "newarticletext" ], "mw-newarticletext" ];
yield 'User exists' =>
[ 'User:Bob', null, 'Alice', null, [ 'User:Bob' => '' ],
[], null ];
yield 'IP user exists, I guess' =>
[ 'User:1.2.3.4', null, 'Alice', null, [ 'User:1.2.3.4' => '' ],
[], null ];
// Editintro
yield 'Default edit intro for missing page' =>
[ 'Does-not-exist-asdfasdf', null, 'Alice', null, [],
[ "newarticletext" ], "mw-newarticletext" ];
yield 'The "editintro" parameter replaces the default edit intro' =>
[ 'Does-not-exist-asdfasdf', null, 'Alice', 'Template:Editintro', [ 'Template:Editintro' => '(editintro)' ],
[ "editintro" ], null ];
// So many more cases to add...
}
/**
* @dataProvider provideCases
*/
public function testGetIntroMessages( $title, $oldid, $user, $editIntro, $pages, $expectedMessages, $expectedWrap ) {
foreach ( $pages as $page => $content ) {
$this->editPage( $page, $content );
}
if ( $user ) {
$userObj = UserIdentityValue::newRegistered( 1, $user );
} else {
$userObj = UserIdentityValue::newAnonymous( '1.2.3.4' );
}
$parameters = [
// These messages are always included, skip them to simplify expected values
[ 'editnotice-notext', 'editpage-head-copy-warn' ],
new MockMessageLocalizer( 'qqx' ),
Title::newFromText( $title )->toPageIdentity(),
null,
new UltimateAuthority( $userObj ),
$editIntro,
null,
false
];
$result = $this->introMessageBuilder->getIntroMessages( IntroMessageBuilder::LESS_FRAMES, ...$parameters );
$resultLessFrames = implode( '', $result );
$result = $this->introMessageBuilder->getIntroMessages( IntroMessageBuilder::MORE_FRAMES, ...$parameters );
$resultMoreFrames = implode( '', $result );
// Find anything that looks like a message in the output
preg_match_all( '/[(](.+?)[):]/', $resultLessFrames, $matches, PREG_PATTERN_ORDER );
$this->assertEquals( $expectedMessages, $matches[1], 'Messages (less frames)' );
if ( $expectedWrap !== null ) {
$this->assertStringNotContainsString( $expectedWrap, $resultLessFrames, 'No frames (less frames)' );
}
preg_match_all( '/[(](.+?)[):]/', $resultMoreFrames, $matches, PREG_PATTERN_ORDER );
$this->assertEquals( $expectedMessages, $matches[1], 'Messages (more frames)' );
if ( $expectedWrap !== null ) {
$this->assertStringContainsString( $expectedWrap, $resultMoreFrames, 'Frames (more frames)' );
}
if ( $expectedWrap == null ) {
$this->assertEquals( $resultLessFrames, $resultMoreFrames, 'No frames' );
}
}
}
PK ! L # externalstore/ExternalStoreTest.phpnu Iw setService(
'ExternalStoreFactory',
new ExternalStoreFactory( [], [], 'test-id' )
);
$this->assertFalse(
ExternalStore::fetchFromURL( 'ForTesting://cluster1/200' ),
'Deny if wgExternalStores is not set to a non-empty array'
);
}
public static function provideFetchFromURLWithStore() {
yield [ 'Hello', 'ForTesting://cluster1/200', 'Allow ForTesting://cluster1/200' ];
yield [ 'Hello', 'ForTesting://cluster1/300/0', 'Allow ForTesting://cluster1/300/0' ];
// cases for r68900
yield [ false, 'ftp.example.org', 'Deny domain ftp.example.org' ];
yield [ false, '/example.txt', 'Deny path /example.txt' ];
yield [ false, 'http://', 'Deny protocol http://' ];
}
/**
* @covers \ExternalStore::fetchFromURL
* @dataProvider provideFetchFromURLWithStore
*/
public function testExternalFetchFromURL_someExternalStore( $expect, $url, $msg ) {
$this->setService(
'ExternalStoreFactory',
new ExternalStoreFactory( [ 'ForTesting' ], [ 'ForTesting://cluster1' ], 'test-id' )
);
$this->assertSame( $expect, ExternalStore::fetchFromURL( $url ), $msg );
}
}
PK ! E * externalstore/ExternalStoreFactoryTest.phpnu Iw expectException( ExternalStoreException::class );
$factory->getStore( 'ForTesting' );
}
public function testExternalStoreFactory_noStores2() {
$factory = new ExternalStoreFactory( [], [], 'test-id' );
$this->expectException( ExternalStoreException::class );
$factory->getStore( 'foo' );
}
public static function provideStoreNames() {
yield 'Same case as construction' => [ 'ForTesting' ];
yield 'All lower case' => [ 'fortesting' ];
yield 'All upper case' => [ 'FORTESTING' ];
yield 'Mix of cases' => [ 'FOrTEsTInG' ];
}
/**
* @dataProvider provideStoreNames
*/
public function testExternalStoreFactory_someStore_protoMatch( $proto ) {
$factory = new ExternalStoreFactory( [ 'ForTesting' ], [], 'test-id' );
$store = $factory->getStore( $proto );
$this->assertInstanceOf( ExternalStoreForTesting::class, $store );
}
/**
* @dataProvider provideStoreNames
*/
public function testExternalStoreFactory_someStore_noProtoMatch( $proto ) {
$factory = new ExternalStoreFactory( [ 'SomeOtherClassName' ], [], 'test-id' );
$this->expectException( ExternalStoreException::class );
$factory->getStore( $proto );
}
/**
* @covers \ExternalStoreFactory::getProtocols
* @covers \ExternalStoreFactory::getWriteBaseUrls
* @covers \ExternalStoreFactory::getStore
*/
public function testStoreFactoryBasic() {
$active = [ 'memory', 'mwstore' ];
$defaults = [ 'memory://cluster1', 'memory://cluster2', 'mwstore://memstore1' ];
$esFactory = new ExternalStoreFactory( $active, $defaults, 'db-prefix' );
$this->overrideConfigValue( MainConfigNames::FileBackends, [
[
'name' => 'memstore1',
'class' => MemoryFileBackend::class,
'domain' => 'its-all-in-your-head',
'readOnly' => 'reason is a lie',
'lockManager' => 'nullLockManager'
]
] );
$this->assertEquals( $active, $esFactory->getProtocols() );
$this->assertEquals( $defaults, $esFactory->getWriteBaseUrls() );
/** @var ExternalStoreMemory $store */
$store = $esFactory->getStore( 'memory' );
$this->assertInstanceOf( ExternalStoreMemory::class, $store );
$this->assertFalse( $store->isReadOnly( 'cluster1' ), "Location is writable" );
$this->assertFalse( $store->isReadOnly( 'cluster2' ), "Location is writable" );
$mwStore = $esFactory->getStore( 'mwstore' );
$this->assertTrue( $mwStore->isReadOnly( 'memstore1' ), "Location is read-only" );
$lb = $this->createMock( LoadBalancer::class );
$lb->method( 'getReadOnlyReason' )->willReturn( 'Locked' );
$lbFactory = $this->createMock( LBFactory::class );
$lbFactory->method( 'getExternalLB' )->willReturn( $lb );
$this->setService( 'DBLoadBalancerFactory', $lbFactory );
$active = [ 'db', 'mwstore' ];
$defaults = [ 'db://clusterX' ];
$esFactory = new ExternalStoreFactory( $active, $defaults, 'db-prefix' );
$this->assertEquals( $active, $esFactory->getProtocols() );
$this->assertEquals( $defaults, $esFactory->getWriteBaseUrls() );
$store->clear();
}
/**
* @covers \ExternalStoreFactory::getStoreForUrl
* @covers \ExternalStoreFactory::getStoreLocationFromUrl
*/
public function testStoreFactoryReadWrite() {
$active = [ 'memory' ]; // active store types
$defaults = [ 'memory://cluster1', 'memory://cluster2' ];
$esFactory = new ExternalStoreFactory( $active, $defaults, 'db-prefix' );
$access = new ExternalStoreAccess( $esFactory );
/** @var ExternalStoreMemory $storeLocal */
$storeLocal = $esFactory->getStore( 'memory' );
/** @var ExternalStoreMemory $storeOther */
$storeOther = $esFactory->getStore( 'memory', [ 'domain' => 'other' ] );
$this->assertInstanceOf( ExternalStoreMemory::class, $storeLocal );
$this->assertInstanceOf( ExternalStoreMemory::class, $storeOther );
$v1 = wfRandomString();
$v2 = wfRandomString();
$v3 = wfRandomString();
$this->assertFalse( $storeLocal->fetchFromURL( 'memory://cluster1/1' ) );
$url1 = 'memory://cluster1/1';
$this->assertEquals(
$url1,
$esFactory->getStoreForUrl( 'memory://cluster1' )
->store( $esFactory->getStoreLocationFromUrl( 'memory://cluster1' ), $v1 )
);
$this->assertEquals(
$v1,
$esFactory->getStoreForUrl( 'memory://cluster1/1' )
->fetchFromURL( 'memory://cluster1/1' )
);
$this->assertEquals( $v1, $storeLocal->fetchFromURL( 'memory://cluster1/1' ) );
$url2 = $access->insert( $v2 );
$url3 = $access->insert( $v3, [ 'domain' => 'other' ] );
$this->assertNotFalse( $url2 );
$this->assertNotFalse( $url3 );
// There is only one active store type
$this->assertEquals( $v2, $storeLocal->fetchFromURL( $url2 ) );
$this->assertEquals( $v3, $storeOther->fetchFromURL( $url3 ) );
$this->assertFalse( $storeOther->fetchFromURL( $url2 ) );
$this->assertFalse( $storeLocal->fetchFromURL( $url3 ) );
$res = $access->fetchFromURLs( [ $url1, $url2, $url3 ] );
$this->assertEquals( [ $url1 => $v1, $url2 => $v2, $url3 => false ], $res, "Local-only" );
$storeLocal->clear();
$storeOther->clear();
}
}
PK ! %Tw w ) externalstore/ExternalStoreAccessTest.phpnu Iw assertFalse( $access->isReadOnly() );
/** @var ExternalStoreMemory $store */
$store = $esFactory->getStore( 'memory' );
$this->assertInstanceOf( ExternalStoreMemory::class, $store );
$location = $esFactory->getStoreLocationFromUrl( 'memory://cluster1' );
$this->assertFalse( $store->isReadOnly( $location ) );
}
/**
* @covers \ExternalStoreAccess::isReadOnly
*/
public function testReadOnly() {
/** @var ExternalStoreMedium|MockObject $medium */
$medium = $this->createMock( ExternalStoreMedium::class );
$medium->method( 'isReadOnly' )->willReturn( true );
/** @var ExternalStoreFactory|MockObject $esFactory */
$esFactory = $this->createMock( ExternalStoreFactory::class );
$esFactory->method( 'getWriteBaseUrls' )->willReturn( [ 'test:' ] );
$esFactory->method( 'getStoreForUrl' )->willReturn( $medium );
$esFactory->method( 'getStoreLocationFromUrl' )->willReturn( 'dummy' );
$access = new ExternalStoreAccess( $esFactory );
$this->assertTrue( $access->isReadOnly() );
$this->setService( 'ReadOnlyMode', $this->getDummyReadOnlyMode( 'Some absurd reason' ) );
$this->expectException( ReadOnlyError::class );
$access->insert( 'Lorem Ipsum' );
}
/**
* @covers \ExternalStoreAccess::fetchFromURL
* @covers \ExternalStoreAccess::fetchFromURLs
* @covers \ExternalStoreAccess::insert
*/
public function testReadWrite() {
$active = [ 'memory' ]; // active store types
$defaults = [ 'memory://cluster1', 'memory://cluster2' ];
$esFactory = new ExternalStoreFactory( $active, $defaults, 'db-prefix' );
$access = new ExternalStoreAccess( $esFactory );
/** @var ExternalStoreMemory $storeLocal */
$storeLocal = $esFactory->getStore( 'memory' );
/** @var ExternalStoreMemory $storeOther */
$storeOther = $esFactory->getStore( 'memory', [ 'domain' => 'other' ] );
$this->assertInstanceOf( ExternalStoreMemory::class, $storeLocal );
$this->assertInstanceOf( ExternalStoreMemory::class, $storeOther );
$v1 = wfRandomString();
$v2 = wfRandomString();
$v3 = wfRandomString();
$this->assertFalse( $storeLocal->fetchFromURL( 'memory://cluster1/1' ) );
$url1 = 'memory://cluster1/1';
$this->assertEquals(
$url1,
$esFactory->getStoreForUrl( 'memory://cluster1' )
->store( $esFactory->getStoreLocationFromUrl( 'memory://cluster1' ), $v1 )
);
$this->assertEquals(
$v1,
$esFactory->getStoreForUrl( 'memory://cluster1/1' )
->fetchFromURL( 'memory://cluster1/1' )
);
$this->assertEquals( $v1, $storeLocal->fetchFromURL( 'memory://cluster1/1' ) );
$url2 = $access->insert( $v2 );
$url3 = $access->insert( $v3, [ 'domain' => 'other' ] );
$this->assertNotFalse( $url2 );
$this->assertNotFalse( $url3 );
// There is only one active store type
$this->assertEquals( $v2, $storeLocal->fetchFromURL( $url2 ) );
$this->assertEquals( $v3, $storeOther->fetchFromURL( $url3 ) );
$this->assertFalse( $storeOther->fetchFromURL( $url2 ) );
$this->assertFalse( $storeLocal->fetchFromURL( $url3 ) );
$res = $access->fetchFromURLs( [ $url1, $url2, $url3 ] );
$this->assertEquals( [ $url1 => $v1, $url2 => $v2, $url3 => false ], $res, "Local-only" );
$storeLocal->clear();
$storeOther->clear();
}
}
PK ! u'O O ) externalstore/ExternalStoreForTesting.phpnu Iw [
'200' => 'Hello',
'300' => [
'Hello', 'World',
],
// gzip string below generated with gzdeflate( 'AAAABBAAA' )
'12345' => "sttttr\002\022\000",
],
];
/**
* Fetch data from given URL
* @param string $url An url of the form FOO://cluster/id or FOO://cluster/id/itemid.
* @return mixed
*/
public function fetchFromURL( $url ) {
// Based on ExternalStoreDB
$path = explode( '/', $url );
$cluster = $path[2];
$id = $path[3];
$itemID = $path[4] ?? false;
if ( !isset( $this->data[$cluster][$id] ) ) {
return null;
}
if ( $itemID !== false
&& is_array( $this->data[$cluster][$id] )
&& isset( $this->data[$cluster][$id][$itemID] )
) {
return $this->data[$cluster][$id][$itemID];
}
return $this->data[$cluster][$id];
}
public function store( $location, $data ) {
$itemId = mt_rand( 500, 1000 );
$this->data[$location][$itemId] = $data;
return "ForTesting://$location/$itemId";
}
public function isReadOnly() {
return false;
}
}
PK ! kupload = new UploadTestHandler;
$this->overrideConfigValue(
MainConfigNames::InterwikiCache,
ClassicInterwikiLookup::buildCdbHash( [
// no entries, no interwiki prefixes
] )
);
}
/**
* First checks the return code
* of UploadBase::getTitle() and then the actual returned title
*
* @dataProvider provideTestTitleValidation
* @covers \UploadBase::getTitle
*/
public function testTitleValidation( $srcFilename, $dstFilename, $code, $msg ) {
/* Check the result code */
$this->assertEquals( $code,
$this->upload->testTitleValidation( $srcFilename ),
"$msg code" );
/* If we expect a valid title, check the title itself. */
if ( $code == UploadBase::OK ) {
$this->assertEquals( $dstFilename,
$this->upload->getTitle()->getText(),
"$msg text" );
}
}
/**
* Test various forms of valid and invalid titles that can be supplied.
*/
public static function provideTestTitleValidation() {
return [
/* Test a valid title */
[ 'ValidTitle.jpg', 'ValidTitle.jpg', UploadBase::OK,
'upload valid title' ],
/* A title with a slash */
[ 'A/B.jpg', 'A-B.jpg', UploadBase::OK,
'upload title with slash' ],
/* A title with illegal char */
[ 'A:B.jpg', 'A-B.jpg', UploadBase::OK,
'upload title with colon' ],
/* Stripping leading File: prefix */
[ 'File:C.jpg', 'C.jpg', UploadBase::OK,
'upload title with File prefix' ],
/* Test illegal suggested title (r94601) */
[ '%281%29.JPG', null, UploadBase::ILLEGAL_FILENAME,
'illegal title for upload' ],
/* A title without extension */
[ 'A', null, UploadBase::FILETYPE_MISSING,
'upload title without extension' ],
/* A title with no basename */
[ '.jpg', null, UploadBase::MIN_LENGTH_PARTNAME,
'upload title without basename' ],
/* A title that is longer than 255 bytes */
[ str_repeat( 'a', 255 ) . '.jpg', null, UploadBase::FILENAME_TOO_LONG,
'upload title longer than 255 bytes' ],
/* A title that is longer than 240 bytes */
[ str_repeat( 'a', 240 ) . '.jpg', null, UploadBase::FILENAME_TOO_LONG,
'upload title longer than 240 bytes' ],
];
}
/**
* Test the upload verification functions
* @covers \UploadBase::verifyUpload
*/
public function testVerifyUpload() {
/* Setup with zero file size */
$this->upload->initializePathInfo( '', '', 0 );
$result = $this->upload->verifyUpload();
$this->assertEquals( UploadBase::EMPTY_FILE,
$result['status'],
'upload empty file' );
}
// Helper used to create an empty file of size $size.
private function createFileOfSize( $size ) {
$filename = $this->getNewTempFile();
$fh = fopen( $filename, 'w' );
ftruncate( $fh, $size );
fclose( $fh );
return $filename;
}
/**
* @covers \UploadBase::verifyUpload
*
* test uploading a 100 bytes file with $wgMaxUploadSize = 100
*
* This method should be abstracted so we can test different settings.
*/
public function testMaxUploadSize() {
$this->overrideConfigValues( [
MainConfigNames::MaxUploadSize => 100,
MainConfigNames::FileExtensions => [
'txt',
],
] );
$filename = $this->createFileOfSize( 100 );
$this->upload->initializePathInfo( basename( $filename ) . '.txt', $filename, 100 );
$result = $this->upload->verifyUpload();
$this->assertEquals(
[ 'status' => UploadBase::OK ],
$result
);
}
/**
* @covers \UploadBase::checkSvgScriptCallback
* @dataProvider provideCheckSvgScriptCallback
*/
public function testCheckSvgScriptCallback( $svg, $wellFormed, $filterMatch, $message ) {
[ $formed, $match ] = $this->upload->checkSvgString( $svg );
$this->assertSame( $wellFormed, $formed, $message . " (well-formed)" );
$this->assertSame( $filterMatch, $match, $message . " (filter match)" );
}
public static function provideCheckSvgScriptCallback() {
return [
// html5sec SVG vectors
[
'',
true, /* SVG is well formed */
true, /* Evil SVG detected */
'Script tag in svg (http://html5sec.org/#47)'
],
[
'',
true,
true,
'SVG with onload property (http://html5sec.org/#11)'
],
[
'',
true,
true,
'SVG with onload property (http://html5sec.org/#65)'
],
[
'',
true,
true,
'SVG with svg:onload on a non-svg element (probably not a thing)'
],
[
'',
true,
true,
'SVG with javascript xlink (http://html5sec.org/#87)'
],
[
'',
true,
true,
'SVG with Opera image xlink (http://html5sec.org/#88 - c)'
],
[
'',
true,
true,
'SVG with Opera animation xlink (http://html5sec.org/#88 - a)'
],
[
'',
true,
true,
'SVG with Opera animation xlink (http://html5sec.org/#88 - b)'
],
[
'',
true,
true,
'SVG with Opera image xlink (http://html5sec.org/#88 - c)'
],
[
'',
true,
true,
'SVG with Opera foreignObject xlink (http://html5sec.org/#88 - d)'
],
[
'',
true,
true,
'SVG with Opera foreignObject xlink (http://html5sec.org/#88 - e)'
],
[
'',
true,
true,
'SVG with event handler set (http://html5sec.org/#89 - a)'
],
[
'',
true,
true,
'SVG with event handler animate (http://html5sec.org/#89 - a)'
],
[
'',
true,
true,
'SVG with element handler (http://html5sec.org/#94)'
],
[
'',
true,
true,
'SVG with href to data: url (http://html5sec.org/#95)'
],
[
'',
true,
true,
'SVG with Tiny handler (http://html5sec.org/#104)'
],
[
'',
true,
true,
'SVG with new CSS styles properties (http://html5sec.org/#109)'
],
[
'',
true,
true,
'SVG with new CSS styles properties as attributes'
],
[
'',
true,
true,
'SVG with new CSS styles properties as attributes (2)'
],
[
'',
true,
true,
'SVG with path marker-start (http://html5sec.org/#110)'
],
[
' ]> ',
false,
true,
'SVG with embedded stylesheet (http://html5sec.org/#125)'
],
[
' ',
true,
true,
'SVG with embedded stylesheet no doctype'
],
[
'',
true,
true,
'SVG with handler attribute (http://html5sec.org/#127)'
],
[
// Haven't found a browser that accepts this particular example, but we
// don't want to allow embeded svgs, ever
'',
true,
true,
'SVG with image filter via style (http://html5sec.org/#129)'
],
[
// This doesn't seem possible without embedding the svg, but just in case
'',
true,
true,
'SVG with animate from (http://html5sec.org/#137)'
],
[
'',
true,
true,
'SVG with animate xlink:href (http://html5sec.org/#137)'
],
[
'',
true,
true,
'SVG with animate y:href (http://html5sec.org/#137)'
],
// Other hostile SVG's
[
' ',
true,
true,
'SVG with non-local image href (T67839)'
],
[
' ',
true,
true,
'SVG with remote stylesheet (T59550)'
],
[
'',
true,
true,
'SVG with rembeded iframe (T62771)'
],
[
'',
true,
true,
'SVG with @import in style element (T71008)'
],
[
'',
true,
true,
'SVG with @import in style element and child element (T71008#c11)'
],
[
'',
true,
true,
'SVG with case-insensitive @import in style element (bug T85349)'
],
[
'',
true,
true,
'SVG with remote background image (T71008)'
],
[
'',
true,
true,
'SVG with remote background image, encoded (T71008)'
],
[
'',
true,
true,
'SVG with remote background image, in style element (T71008)'
],
[
// This currently doesn't seem to work in any browsers, but in case
// https://www.w3.org/TR/css3-images/ is implemented for SVG files
'',
true,
true,
'SVG with remote background image using image() (T71008)'
],
[
// As reported by Cure53
'',
true,
true,
'SVG with data:text/html link target (firefox only)'
],
[
' ]> ',
false,
true,
'SVG with encoded script tag in internal entity (reported by Beyond Security)'
],
[
' ]> ',
false,
false,
'SVG with external entity'
],
[
// The base64 = . If for some reason
// entities actually do get loaded, this should trigger
// filterMatch to be true. So this test verifies that we
// are not loading external entities.
' ]> ',
false,
false, /* False verifies entities aren't getting loaded */
'SVG with data: uri external entity'
],
[
"",
true,
true,
'SVG with javascript link with newline (T122653)'
],
// Test good, but strange files that we want to allow
[
'',
true,
false,
'SVG with link to a remote site'
],
[
'',
true,
false,
'SVG with local urls, including filter: in style'
],
[
' ]> ',
false,
false,
'SVG with evil default attribute values'
],
[
'',
true,
true,
'SVG with an evil external dtd'
],
[
'',
true,
true,
'SVG with random public doctype'
],
[
'',
true,
true,
'SVG with random SYSTEM doctype'
],
[
'] >',
false,
false,
'SVG with parameter entity'
],
[
'',
false,
false,
'SVG with entity referencing parameter entity'
],
[
' ] >',
false,
false,
'SVG with long entity'
],
[
' ] >',
true,
false,
'SVG with apostrophe quote entity'
],
[
' ] >',
false,
false,
'SVG with recursive entity',
],
[
' ]> ',
true, /* well-formed */
false, /* filter-hit */
'GraphViz-esque svg with #FIXED xlink ns (Should be allowed)'
],
[
' ]> ',
false,
false,
'GraphViz ATLIST exception should match exactly'
],
[
' ]>',
true,
false,
'DTD with comments (Should be allowed)'
],
[
' ]>',
false,
false,
'DTD with invalid comment'
],
[
' ]>',
false,
false,
'DTD with invalid comment 2'
],
[
' ]>',
true,
false,
'DTD with aliased entities (Should be allowed)'
],
[
' ]>',
true,
false,
'DTD with aliased entities apos (Should be allowed)'
],
[
'',
true,
false,
'SVG with local filter (T69044)'
],
[
'',
true,
true,
'SVG with non-local filter (T69044)'
],
];
// phpcs:enable
}
/**
* @covers \UploadBase::detectScriptInSvg
* @dataProvider provideDetectScriptInSvg
*/
public function testDetectScriptInSvg( $svg, $expected, $message ) {
// This only checks some weird cases, most tests are in testCheckSvgScriptCallback() above
$result = $this->upload->detectScriptInSvg( $svg, false );
$this->assertSame( $expected, $result, $message );
}
public static function provideDetectScriptInSvg() {
global $IP;
return [
[
$IP . self::UPLOAD_PATH . "buggynamespace-original.svg",
false,
'SVG with a weird but valid namespace definition created by Adobe Illustrator'
],
[
$IP . self::UPLOAD_PATH . "buggynamespace-okay.svg",
false,
'SVG with a namespace definition created by Adobe Illustrator and mangled by Inkscape'
],
[
$IP . self::UPLOAD_PATH . "buggynamespace-okay2.svg",
false,
'SVG with a namespace definition created by Adobe Illustrator and mangled by Inkscape (twice)'
],
[
$IP . self::UPLOAD_PATH . "inkscape-only-selected.svg",
false,
'SVG with an inkscape only-selected attribute'
],
[
$IP . self::UPLOAD_PATH . "buggynamespace-bad.svg",
[ 'uploadscriptednamespace', 'i' ],
'SVG with a namespace definition using an undefined entity'
],
[
$IP . self::UPLOAD_PATH . "buggynamespace-evilhtml.svg",
[ 'uploadscriptednamespace', 'http://www.w3.org/1999/xhtml' ],
'SVG with an html namespace encoded as an entity'
],
];
}
/**
* @covers \UploadBase::checkXMLEncodingMissmatch
* @dataProvider provideCheckXMLEncodingMissmatch
*/
public function testCheckXMLEncodingMissmatch( $fileContents, $evil ) {
$filename = $this->getNewTempFile();
file_put_contents( $filename, $fileContents );
$this->assertSame( $evil, UploadBase::checkXMLEncodingMissmatch( $filename ) );
}
public static function provideCheckXMLEncodingMissmatch() {
return [
[ '', true ],
[ '', false ],
[ '', false ],
[ '', false ],
];
}
/**
* @covers \UploadBase::detectScript
* @dataProvider provideDetectScript
*/
public function testDetectScript( $filename, $mime, $extension, $expected, $message ) {
$result = $this->upload->detectScript( $filename, $mime, $extension );
$this->assertSame( $expected, $result, $message );
}
public static function provideDetectScript() {
global $IP;
return [
[
$IP . self::UPLOAD_PATH . "png-plain.png",
'image/png',
'png',
false,
'PNG with no suspicious things in it; should pass.'
],
[
$IP . self::UPLOAD_PATH . "png-embedded-breaks-ie5.png",
'image/png',
'png',
true,
'PNG with embedded data that IE5/6 interprets as HTML; should be rejected.'
],
[
$IP . self::UPLOAD_PATH . "jpeg-a-href-in-metadata.jpg",
'image/jpeg',
'jpeg',
false,
'JPEG with innocuous HTML in metadata from a flickr photo; should pass (T27707).',
],
];
}
}
class UploadTestHandler extends UploadBase {
public function initializeFromRequest( &$request ) {
}
public function testTitleValidation( $name ) {
$this->mTitle = false;
$this->mDesiredDestName = $name;
$this->mTitleError = UploadBase::OK;
$this->getTitle();
return $this->mTitleError;
}
/**
* Almost the same as UploadBase::detectScriptInSvg, except it's
* public, works on an xml string instead of filename, and returns
* the result instead of interpreting them.
* @param string $svg
* @return array
*/
public function checkSvgString( $svg ) {
$check = new XmlTypeCheck(
$svg,
[ $this, 'checkSvgScriptCallback' ],
false,
[
'processing_instruction_handler' => [ UploadBase::class, 'checkSvgPICallback' ],
'external_dtd_handler' => [ UploadBase::class, 'checkSvgExternalDTD' ],
]
);
return [ $check->wellFormed, $check->filterMatch ];
}
/**
* Same as parent function, but override visibility to 'public'.
* @inheritDoc
*/
public function detectScriptInSvg( $filename, $partial ) {
return parent::detectScriptInSvg( $filename, $partial );
}
}
PK ! .q q upload/UploadStashTest.phpnu Iw tmpFile = $this->getNewTempFile();
file_put_contents( $this->tmpFile, "\x00" );
}
public static function provideInvalidRequests() {
return [
'Check failure on bad wpFileKey' =>
[ new FauxRequest( [ 'wpFileKey' => 'foo' ] ) ],
'Check failure on bad wpSessionKey' =>
[ new FauxRequest( [ 'wpSessionKey' => 'foo' ] ) ],
];
}
/**
* @dataProvider provideInvalidRequests
*/
public function testValidRequestWithInvalidRequests( $request ) {
$this->assertFalse( UploadFromStash::isValidRequest( $request ) );
}
public static function provideValidRequests() {
return [
'Check good wpFileKey' =>
[ new FauxRequest( [ 'wpFileKey' => 'testkey-test.test' ] ) ],
'Check good wpSessionKey' =>
[ new FauxRequest( [ 'wpFileKey' => 'testkey-test.test' ] ) ],
'Check key precedence' =>
[ new FauxRequest( [
'wpFileKey' => 'testkey-test.test',
'wpSessionKey' => 'foo'
] ) ],
];
}
/**
* @dataProvider provideValidRequests
*/
public function testValidRequestWithValidRequests( $request ) {
$this->assertTrue( UploadFromStash::isValidRequest( $request ) );
}
}
PK ! % % upload/UploadFromUrlTest.phpnu Iw user = $this->getTestSysop()->getUser();
$this->overrideConfigValues( [
MainConfigNames::EnableUploads => true,
MainConfigNames::AllowCopyUploads => true,
] );
$this->setGroupPermissions( 'sysop', 'upload_by_url', true );
if ( $this->getServiceContainer()->getRepoGroup()->getLocalRepo()
->newFile( 'UploadFromUrlTest.png' )->exists()
) {
$this->deleteFile( 'UploadFromUrlTest.png' );
}
$this->installMockHttp();
}
/**
* Ensure that the job queue is empty before continuing
*/
public function testClearQueue() {
$jobQueueGroup = $this->getServiceContainer()->getJobQueueGroup();
$job = $jobQueueGroup->pop();
while ( $job ) {
$job = $jobQueueGroup->pop();
}
$this->assertFalse( $job );
}
public function testIsAllowedHostEmpty() {
$this->overrideConfigValues( [
MainConfigNames::CopyUploadsDomains => [],
MainConfigNames::CopyUploadAllowOnWikiDomainConfig => false,
] );
$this->assertTrue( UploadFromUrl::isAllowedHost( 'https://foo.bar' ) );
}
public function testIsAllowedHostDirectMatch() {
$this->overrideConfigValues( [
MainConfigNames::CopyUploadsDomains => [
'foo.baz',
'bar.example.baz',
],
MainConfigNames::CopyUploadAllowOnWikiDomainConfig => false,
] );
$this->assertFalse( UploadFromUrl::isAllowedHost( 'https://example.com' ) );
$this->assertTrue( UploadFromUrl::isAllowedHost( 'https://foo.baz' ) );
$this->assertFalse( UploadFromUrl::isAllowedHost( 'https://.foo.baz' ) );
$this->assertFalse( UploadFromUrl::isAllowedHost( 'https://example.baz' ) );
$this->assertTrue( UploadFromUrl::isAllowedHost( 'https://bar.example.baz' ) );
}
public function testIsAllowedHostLastWildcard() {
$this->overrideConfigValues( [
MainConfigNames::CopyUploadsDomains => [
'*.baz',
],
MainConfigNames::CopyUploadAllowOnWikiDomainConfig => false,
] );
$this->assertFalse( UploadFromUrl::isAllowedHost( 'https://baz' ) );
$this->assertFalse( UploadFromUrl::isAllowedHost( 'https://foo.example' ) );
$this->assertFalse( UploadFromUrl::isAllowedHost( 'https://foo.example.baz' ) );
$this->assertFalse( UploadFromUrl::isAllowedHost( 'https://foo/bar.baz' ) );
$this->assertTrue( UploadFromUrl::isAllowedHost( 'https://foo.baz' ) );
$this->assertFalse( UploadFromUrl::isAllowedHost( 'https://subdomain.foo.baz' ) );
}
public function testIsAllowedHostWildcardInMiddle() {
$this->overrideConfigValues( [
MainConfigNames::CopyUploadsDomains => [
'foo.*.baz',
],
MainConfigNames::CopyUploadAllowOnWikiDomainConfig => false,
] );
$this->assertFalse( UploadFromUrl::isAllowedHost( 'https://foo.baz' ) );
$this->assertFalse( UploadFromUrl::isAllowedHost( 'https://foo.bar.bar.baz' ) );
$this->assertFalse( UploadFromUrl::isAllowedHost( 'https://foo.bar.baz.baz' ) );
$this->assertFalse( UploadFromUrl::isAllowedHost( 'https://foo.com/.baz' ) );
$this->assertTrue( UploadFromUrl::isAllowedHost( 'https://foo.example.baz' ) );
$this->assertTrue( UploadFromUrl::isAllowedHost( 'https://foo.bar.baz' ) );
}
public function testOnWikiDomainConfigEnabled() {
$this->overrideConfigValues( [
MainConfigNames::CopyUploadsDomains => [ 'example.com' ],
MainConfigNames::CopyUploadAllowOnWikiDomainConfig => true,
] );
$messageContent = "example.org # this is a comment\n# this too is commented foo.example.com\nexample.net";
$mock = $this->createMock( MessageCache::class );
$mock->method( 'get' )->willReturn( $messageContent );
$this->setService( 'MessageCache', $mock );
$this->assertEquals(
[ 'example.com', 'example.org', 'example.net' ],
TestingAccessWrapper::newFromClass( UploadFromUrl::class )->getAllowedHosts()
);
$this->assertTrue( UploadFromUrl::isAllowedHost( 'https://example.com' ) );
$this->assertTrue( UploadFromUrl::isAllowedHost( 'https://example.org' ) );
$this->assertFalse( UploadFromUrl::isAllowedHost( 'https://foo.example.com' ) );
}
public function testOnWikiDomainConfigDisabled() {
$this->overrideConfigValues( [
MainConfigNames::CopyUploadsDomains => [ 'example.com' ],
MainConfigNames::CopyUploadAllowOnWikiDomainConfig => false,
] );
$mock = $this->createMock( MessageCache::class );
$mock->expects( $this->never() )->method( 'get' );
$this->setService( 'MessageCache', $mock );
$this->assertEquals(
[ 'example.com' ],
TestingAccessWrapper::newFromClass( UploadFromUrl::class )->getAllowedHosts()
);
$this->assertTrue( UploadFromUrl::isAllowedHost( 'https://example.com' ) );
$this->assertFalse( UploadFromUrl::isAllowedHost( 'https://example.org' ) );
}
/**
* @depends testClearQueue
*/
public function testSetupUrlDownload( $data ) {
$token = $this->user->getEditToken();
$exception = false;
try {
$this->doApiRequest( [
'action' => 'upload',
] );
} catch ( ApiUsageException $e ) {
$exception = true;
$this->assertApiErrorCode( 'missingparam', $e );
}
$this->assertTrue( $exception, "Got exception" );
$exception = false;
try {
$this->doApiRequest( [
'action' => 'upload',
'token' => $token,
], $data );
} catch ( ApiUsageException $e ) {
$exception = true;
$this->assertApiErrorCode( 'missingparam', $e );
}
$this->assertTrue( $exception, "Got exception" );
$exception = false;
try {
$this->doApiRequest( [
'action' => 'upload',
'url' => 'http://www.example.com/test.png',
'token' => $token,
], $data );
} catch ( ApiUsageException $e ) {
$exception = true;
$this->assertApiErrorCode( 'nofilename', $e );
}
$this->assertTrue( $exception, "Got exception" );
$this->getServiceContainer()->getUserGroupManager()->removeUserFromGroup( $this->user, 'sysop' );
$exception = false;
try {
$this->doApiRequest( [
'action' => 'upload',
'url' => 'http://www.example.com/test.png',
'filename' => 'UploadFromUrlTest.png',
'token' => $token,
], $data );
} catch ( ApiUsageException $e ) {
$this->assertApiErrorCode( 'permissiondenied', $e );
$exception = true;
}
$this->assertTrue( $exception, "Got exception" );
}
private function assertUploadOk( UploadBase $upload ) {
$verificationResult = $upload->verifyUpload();
if ( $verificationResult['status'] !== UploadBase::OK ) {
$this->fail(
'Upload verification returned ' . $upload->getVerificationErrorCode(
$verificationResult['status']
)
);
}
}
/**
* @depends testClearQueue
*/
public function testSyncDownload( $data ) {
$file = __DIR__ . '/../../data/upload/png-plain.png';
$this->installMockHttp( file_get_contents( $file ) );
$this->getServiceContainer()->getUserGroupManager()->addUserToGroup( $this->user, 'users' );
$data = $this->doApiRequestWithToken( [
'action' => 'upload',
'filename' => 'UploadFromUrlTest.png',
'url' => 'http://upload.wikimedia.org/wikipedia/mediawiki/b/bc/Wiki.png',
'ignorewarnings' => true,
], $data );
$this->assertEquals( 'Success', $data[0]['upload']['result'] );
$this->deleteFile( 'UploadFromUrlTest.png' );
return $data;
}
protected function deleteFile( $name ) {
$t = Title::newFromText( $name, NS_FILE );
$this->assertTrue( $t->exists(), "File '$name' exists" );
if ( $t->exists() ) {
$file = $this->getServiceContainer()->getRepoGroup()
->findFile( $name, [ 'ignoreRedirect' => true ] );
$empty = "";
FileDeleteForm::doDelete( $t, $file, $empty, "none", true, $this->user );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $t );
$this->deletePage( $page );
}
$t = Title::newFromText( $name, NS_FILE );
$this->assertFalse( $t->exists(), "File '$name' was deleted" );
}
public function testUploadFromUrl() {
$file = __DIR__ . '/../../data/upload/png-plain.png';
$this->installMockHttp( file_get_contents( $file ) );
$upload = new UploadFromUrl();
$upload->initialize( 'Test.png', 'http://www.example.com/test.png' );
$status = $upload->fetchFile();
$this->assertStatusOK( $status );
$this->assertUploadOk( $upload );
}
public function testUploadFromUrlWithRedirect() {
$file = __DIR__ . '/../../data/upload/png-plain.png';
$this->installMockHttp( [
// First response is a redirect
$this->makeFakeHttpRequest(
'Blaba',
302,
[ 'Location' => 'http://static.example.com/files/test.png' ]
),
// Second response is a file
$this->makeFakeHttpRequest(
file_get_contents( $file )
),
] );
$upload = new UploadFromUrl();
$upload->initialize( 'Test.png', 'http://www.example.com/test.png' );
$status = $upload->fetchFile();
$this->assertStatusOK( $status );
$this->assertUploadOk( $upload );
}
public function testUploadFromUrlCacheKey() {
// Test we get back a properly formatted sha1 key out
$key = UploadFromUrl::getCacheKey( [ 'filename' => 'test.png', 'url' => 'https://example.com/example.png' ] );
$this->assertNotEmpty( $key );
$this->assertMatchesRegularExpression( "/^[0-9a-f]{40}$/", $key );
}
public function testUploadFromUrlCacheKeyMissingParam() {
$this->assertSame( "", UploadFromUrl::getCacheKey( [] ) );
}
}
PK ! P% % import/ImportTest.phpnu Iw
*/
class ImportTest extends MediaWikiLangTestCase {
/**
* @covers \WikiImporter
* @dataProvider getUnknownTagsXML
* @param string $xml
* @param string $text
* @param string $title
*/
public function testUnknownXMLTags( $xml, $text, $title ) {
$source = new ImportStringSource( $xml );
$services = $this->getServiceContainer();
$importer = $services->getWikiImporterFactory()->getWikiImporter( $source, $this->getTestSysop()->getAuthority() );
$importer->doImport();
$title = Title::newFromText( $title );
$this->assertTrue( $title->exists() );
$this->assertEquals(
$services->getWikiPageFactory()->newFromTitle( $title )->getContent()->getText(),
$text
);
}
public function getUnknownTagsXML() {
return [
[
<<< EOF
TestImportPage
Should be ignored
0
14
15
Should be ignored
2016-01-03T11:18:43Z
Should be ignored
Admin
1
wikitext
text/x-wiki
noitazinagro tseb eht si ikiWaideM
phoiac9h4m842xq45sp7s6u21eteeq1
Should be ignored
Should be ignored
EOF
,
'noitazinagro tseb eht si ikiWaideM',
'TestImportPage'
]
];
// phpcs:enable
}
/**
* @covers \WikiImporter::handlePage
* @dataProvider getRedirectXML
* @param string $xml
* @param string|null $redirectTitle
*/
public function testHandlePageContainsRedirect( $xml, $redirectTitle ) {
$source = new ImportStringSource( $xml );
$redirect = null;
$callback = static function ( Title $title, ForeignTitle $foreignTitle, $revCount,
$sRevCount, $pageInfo ) use ( &$redirect ) {
if ( array_key_exists( 'redirect', $pageInfo ) ) {
$redirect = $pageInfo['redirect'];
}
};
$importer = $this->getServiceContainer()
->getWikiImporterFactory()
->getWikiImporter( $source, $this->getTestSysop()->getAuthority() );
$importer->setPageOutCallback( $callback );
$importer->doImport();
$this->assertEquals( $redirectTitle, $redirect );
}
public function getRedirectXML() {
return [
[
<<< EOF
Test
0
21
20
2014-05-27T10:00:00Z
Admin
10
Admin moved page [[Test]] to [[Test22]]
wikitext
text/x-wiki
#REDIRECT [[Test22]]
tq456o9x3abm7r9ozi6km8yrbbc56o6
EOF
,
'Test22'
],
[
<<< EOF
Test
0
42
421
2014-05-27T11:00:00Z
Admin
10
Abcd
n7uomjq96szt60fy5w3x7ahf7q8m8rh
wikitext
text/x-wiki
EOF
,
null
],
];
// phpcs:enable
}
/**
* @covers \WikiImporter::handleSiteInfo
* @dataProvider getSiteInfoXML
* @param string $xml
* @param array|null $namespaces
*/
public function testSiteInfoContainsNamespaces( $xml, $namespaces ) {
$source = new ImportStringSource( $xml );
$importNamespaces = null;
$callback = static function ( array $siteinfo, $innerImporter ) use ( &$importNamespaces ) {
$importNamespaces = $siteinfo['_namespaces'];
};
$importer = $this->getServiceContainer()
->getWikiImporterFactory()
->getWikiImporter( $source, $this->getTestSysop()->getAuthority() );
$importer->setSiteInfoCallback( $callback );
$importer->doImport();
$this->assertEquals( $importNamespaces, $namespaces );
}
public function getSiteInfoXML() {
return [
[
<<< EOF
Media
Special
Talk
User
User talk
Portal
Portal talk
EOF
,
[
'-2' => 'Media',
'-1' => 'Special',
'0' => '',
'1' => 'Talk',
'2' => 'User',
'3' => 'User talk',
'100' => 'Portal',
'101' => 'Portal talk',
]
],
];
// phpcs:enable
}
/**
* @dataProvider provideUnknownUserHandling
* @covers \WikiImporter::setUsernamePrefix
* @covers \MediaWiki\User\ExternalUserNames::addPrefix
* @covers \MediaWiki\User\ExternalUserNames::applyPrefix
* @param bool $assign
* @param bool $create
*/
public function testUnknownUserHandling( $assign, $create ) {
$hookId = -99;
$this->setTemporaryHook(
'ImportHandleUnknownUser',
function ( $name ) use ( $assign, $create, &$hookId ) {
if ( !$assign ) {
$this->fail( 'ImportHandleUnknownUser was called unexpectedly' );
}
$this->assertEquals( 'UserDoesNotExist', $name );
if ( $create ) {
$user = User::createNew( $name );
$this->assertNotNull( $user );
$hookId = $user->getId();
return false;
}
return true;
}
);
$user = $this->getTestUser()->getUser();
$n = ( $assign ? 1 : 0 ) + ( $create ? 2 : 0 );
$source = new ImportStringSource( <<
TestImportPage
0
14
15
2016-01-01T0$n:00:00Z
UserDoesNotExist
1
wikitext
text/x-wiki
foo
1e6gpc3ehk0mu2jqu8cg42g009s796b
16
2016-01-01T0$n:00:01Z
{$user->getName()}
{$user->getId()}
wikitext
text/x-wiki
bar
bjhlo6dxh5wivnszm93u4b78fheiy4t
EOF
);
// phpcs:enable
$services = $this->getServiceContainer();
$importer = $services->getWikiImporterFactory()->getWikiImporter( $source, $this->getTestSysop()->getAuthority() );
$importer->setUsernamePrefix( 'Xxx', $assign );
$importer->doImport();
$db = $this->getDb();
$row = $services->getRevisionStore()->newSelectQueryBuilder( $db )
->where( [ 'rev_timestamp' => $db->timestamp( "201601010{$n}0000" ) ] )
->caller( __METHOD__ )->fetchRow();
$this->assertSame(
$assign && $create ? 'UserDoesNotExist' : 'Xxx>UserDoesNotExist',
$row->rev_user_text
);
$this->assertSame( $assign && $create ? $hookId : 0, (int)$row->rev_user );
$row = $services->getRevisionStore()->newSelectQueryBuilder( $db )
->where( [ 'rev_timestamp' => $db->timestamp( "201601010{$n}0001" ) ] )
->caller( __METHOD__ )->fetchRow();
$this->assertSame( ( $assign ? '' : 'Xxx>' ) . $user->getName(), $row->rev_user_text );
$this->assertSame( $assign ? $user->getId() : 0, (int)$row->rev_user );
}
public static function provideUnknownUserHandling() {
return [
'no assign' => [ false, false ],
'assign, no create' => [ true, false ],
'assign, create' => [ true, true ],
];
}
}
PK ! ,# # , import/ImportableOldRevisionImporterTest.phpnu Iw getServiceContainer()->getChangeTagsStore()->defineTag( 'tag1' );
}
public static function provideTestCases() {
yield [ [] ];
yield [ [ "tag1" ] ];
}
/**
* @dataProvider provideTestCases
*/
public function testImport( $expectedTags ) {
$services = $this->getServiceContainer();
$title = Title::newFromText( __CLASS__ . rand() );
$revision = new WikiRevision();
$revision->setTitle( $title );
$revision->setTags( $expectedTags );
$content = ContentHandler::makeContent( 'dummy edit', $title );
$revision->setContent( SlotRecord::MAIN, $content );
$importer = new ImportableOldRevisionImporter(
true,
new NullLogger(),
$services->getConnectionProvider(),
$services->getRevisionStoreFactory()->getRevisionStoreForImport(),
$services->getSlotRoleRegistry(),
$services->getWikiPageFactory(),
$services->getPageUpdaterFactory(),
$services->getUserFactory()
);
$result = $importer->import( $revision );
$this->assertTrue( $result );
$tags = $this->getServiceContainer()->getChangeTagsStore()->getTags(
$this->getDb(),
null,
$title->getLatestRevID()
);
$this->assertSame( $expectedTags, $tags );
}
/**
* @covers \MediaWiki\Revision\RevisionStoreFactory::getRevisionStoreForImport
* @covers \MediaWiki\User\ActorMigration::newMigrationForImport
* @covers \MediaWiki\User\ActorStoreFactory::getActorStoreForImport
* @covers \MediaWiki\User\ActorStoreFactory::getActorNormalizationForImport
* @dataProvider provideTestCases
*/
public function testImportWithTempAccountsEnabled( $expectedTags ) {
$this->enableAutoCreateTempUser();
$this->testImport( $expectedTags );
}
}
PK ! !% import/ImportExportTest.phpnu Iw getServiceContainer()->getSlotRoleRegistry();
if ( !$slotRoleRegistry->isDefinedRole( 'ImportExportTest' ) ) {
$slotRoleRegistry->defineRoleWithModel( 'ImportExportTest', CONTENT_MODEL_WIKITEXT );
}
}
/**
* @param string $schemaVersion
*
* @return WikiExporter
*/
private function getExporter( string $schemaVersion ) {
$exporter = $this->getServiceContainer()
->getWikiExporterFactory()
->getWikiExporter( $this->getDb(), WikiExporter::FULL );
$exporter->setSchemaVersion( $schemaVersion );
return $exporter;
}
/**
* @param ImportSource $source
*
* @return WikiImporter
*/
private function getImporter( ImportSource $source ) {
$config = new HashConfig( [
MainConfigNames::MaxArticleSize => 2048,
] );
$services = $this->getServiceContainer();
$importer = new WikiImporter(
$source,
$this->getTestSysop()->getAuthority(),
$config,
$services->getHookContainer(),
$services->getContentLanguage(),
$services->getNamespaceInfo(),
$services->getTitleFactory(),
$services->getWikiPageFactory(),
$services->getWikiRevisionUploadImporter(),
$services->getContentHandlerFactory(),
$services->getSlotRoleRegistry()
);
return $importer;
}
/**
* @param string $testName
*
* @return string[]
*/
private function getFilesToImport( string $testName ) {
return glob( __DIR__ . "/../../data/import/$testName.import-*.xml" );
}
/**
* @param string $name
* @param string $schemaVersion
*
* @return string path of the dump file
*/
protected function getDumpTemplatePath( $name, $schemaVersion ) {
return __DIR__ . "/../../data/import/$name.$schemaVersion.xml";
}
/**
* @param string $prefix
* @param string[] $keys
*
* @return string[]
*/
private function getUniqueNames( string $prefix, array $keys ) {
$names = [];
foreach ( $keys as $k ) {
$names[$k] = "$prefix-$k-" . wfRandomString( 6 );
}
return $names;
}
/**
* @param string $xmlData
* @param string[] $pageTitles
*
* @return string
*/
private function injectPageTitles( string $xmlData, array $pageTitles ) {
$keys = array_map( static function ( $name ) {
return "{{{$name}_title}}";
}, array_keys( $pageTitles ) );
return str_replace(
$keys,
array_values( $pageTitles ),
$xmlData
);
}
/**
* @param Title $title
*
* @return RevisionRecord[]
*/
private function getRevisions( Title $title ) {
$store = $this->getServiceContainer()->getRevisionStore();
$queryBuilder = $store->newSelectQueryBuilder( $this->getDb() )
->joinComment()
->where( [ 'rev_page' => $title->getArticleID() ] )
->orderBy( 'rev_id', SelectQueryBuilder::SORT_ASC );
$rows = $queryBuilder->caller( __METHOD__ )->fetchResultSet();
$status = $store->newRevisionsFromBatch( $rows );
return $status->getValue();
}
/**
* @param string[] $pageTitles
*
* @return string[]
*/
private function getPageInfoVars( array $pageTitles ) {
$vars = [];
foreach ( $pageTitles as $name => $page ) {
$title = Title::newFromText( $page );
if ( !$title->exists( IDBAccessObject::READ_LATEST ) ) {
// map only existing pages, since only they can appear in a dump
continue;
}
$vars[ $name . '_pageid' ] = $title->getArticleID();
$vars[ $name . '_title' ] = $title->getPrefixedDBkey();
$vars[ $name . '_namespace' ] = $title->getNamespace();
$n = 1;
$revisions = $this->getRevisions( $title );
foreach ( $revisions as $rev ) {
$revkey = "{$name}_rev" . $n++;
$vars[ $revkey . '_id' ] = $rev->getId();
$vars[ $revkey . '_userid' ] = $rev->getUser()->getId();
}
}
return $vars;
}
/**
* @param string $schemaVersion
* @return string[]
*/
private function getSiteVars( $schemaVersion ) {
global $wgSitename, $wgDBname, $wgCapitalLinks;
$vars = [];
$vars['mw_version'] = MW_VERSION;
$vars['schema_version'] = $schemaVersion;
$vars['site_name'] = $wgSitename;
$vars['project_namespace'] =
$this->getServiceContainer()->getTitleFormatter()->getNamespaceName(
NS_PROJECT,
'Dummy'
);
$vars['site_db'] = $wgDBname;
$vars['site_case'] = $wgCapitalLinks ? 'first-letter' : 'case-sensitive';
$vars['site_base'] = Title::newMainPage()->getCanonicalURL();
$vars['site_language'] = $this->getServiceContainer()->getContentLanguage()->getHtmlCode();
return $vars;
}
public static function provideImportExport() {
foreach ( XmlDumpWriter::$supportedSchemas as $schemaVersion ) {
yield [ 'Basic', $schemaVersion ];
yield [ 'Dupes', $schemaVersion ];
yield [ 'Slots', $schemaVersion ];
yield [ 'Interleaved', $schemaVersion ];
yield [ 'InterleavedMulti', $schemaVersion ];
yield [ 'MissingMainContentModel', $schemaVersion ];
yield [ 'MissingSlotContentModel', $schemaVersion ];
}
}
/**
* @dataProvider provideImportExport
*/
public function testImportExport( $testName, $schemaVersion ) {
$asserter = new DumpAsserter( $schemaVersion );
$filesToImport = $this->getFilesToImport( $testName );
$fileToExpect = $this->getDumpTemplatePath( "$testName.expected", $schemaVersion );
$siteInfoExpect = $this->getDumpTemplatePath( 'SiteInfo', $schemaVersion );
$pageKeys = [ 'page1', 'page2', 'page3', 'page4', ];
$pageTitles = $this->getUniqueNames( $testName, $pageKeys );
// import each file
foreach ( $filesToImport as $fileName ) {
$xmlData = file_get_contents( $fileName );
$xmlData = $this->injectPageTitles( $xmlData, $pageTitles );
$source = new ImportStringSource( $xmlData );
$importer = $this->getImporter( $source );
$importer->doImport();
}
// write dump
$exporter = $this->getExporter( $schemaVersion );
$tmpFile = $this->getNewTempFile();
$buffer = new DumpFileOutput( $tmpFile );
$exporter->setOutputSink( $buffer );
$exporter->openStream();
$exporter->pagesByName( $pageTitles );
$exporter->closeStream();
// determine expected variable values
$vars = array_merge(
$this->getSiteVars( $schemaVersion ),
$this->getPageInfoVars( $pageTitles )
);
foreach ( $vars as $key => $value ) {
$asserter->setVarMapping( $key, $value );
}
$dumpData = file_get_contents( $tmpFile );
$this->assertNotEmpty( $dumpData, 'Dump XML' );
// check dump content
$asserter->assertDumpStart( $tmpFile, $siteInfoExpect );
$asserter->assertDOM( $fileToExpect );
$asserter->assertDumpEnd();
}
}
PK ! $xY
Y
import/ImportFailureTest.phpnu Iw getServiceContainer()->getSlotRoleRegistry();
if ( !$slotRoleRegistry->isDefinedRole( 'ImportFailureTest' ) ) {
$slotRoleRegistry->defineRoleWithModel( 'ImportFailureTest', CONTENT_MODEL_WIKITEXT );
}
}
/**
* @param ImportSource $source
* @return WikiImporter
*/
private function getImporter( ImportSource $source ) {
$config = new HashConfig( [
MainConfigNames::MaxArticleSize => 2048,
] );
$services = $this->getServiceContainer();
$importer = new WikiImporter(
$source,
$this->getTestSysop()->getAuthority(),
$config,
$services->getHookContainer(),
$services->getContentLanguage(),
$services->getNamespaceInfo(),
$services->getTitleFactory(),
$services->getWikiPageFactory(),
$services->getWikiRevisionUploadImporter(),
$services->getContentHandlerFactory(),
$services->getSlotRoleRegistry()
);
return $importer;
}
/**
* @param string $testName
*
* @return string
*/
private function getFileToImport( string $testName ) {
return __DIR__ . "/../../data/import/$testName.xml";
}
/**
* @param string $prefix
* @param string[] $keys
*
* @return string[]
*/
private function getUniqueNames( string $prefix, array $keys ) {
$names = [];
foreach ( $keys as $k ) {
$names[$k] = "$prefix-$k-" . wfRandomString( 6 );
}
return $names;
}
/**
* @param string $xmlData
* @param string[] $pageTitles
*
* @return string
*/
private function injectPageTitles( string $xmlData, array $pageTitles ) {
$keys = array_map( static function ( $name ) {
return "{{{$name}_title}}";
}, array_keys( $pageTitles ) );
return str_replace(
$keys,
array_values( $pageTitles ),
$xmlData
);
}
public static function provideImportFailure() {
yield [ 'BadXML', RuntimeException::class, '/^XML error at line 3: Opening and ending tag mismatch:.*$/' ];
yield [ 'MissingMediaWikiTag', UnexpectedValueException::class, "/^Expected '' tag, got .*$/" ];
yield [ 'MissingMainTextField', InvalidArgumentException::class, '/^Missing text field in import.$/' ];
yield [ 'MissingSlotTextField', InvalidArgumentException::class, '/^Missing text field in import.$/' ];
yield [ 'MissingSlotRole', RuntimeException::class, '/^Missing role for imported slot.$/' ];
yield [ 'UndefinedSlotRole', RuntimeException::class, '/^Undefined slot role .*$/' ];
yield [ 'UndefinedContentModel', MWUnknownContentModelException::class, '/not registered on this wiki/' ];
}
/**
* @dataProvider provideImportFailure
*/
public function testImportFailure( $testName, $exceptionName, $exceptionMessage ) {
$fileName = $this->getFileToImport( $testName );
$pageKeys = [ 'page1', 'page2', 'page3', 'page4', ];
$pageTitles = $this->getUniqueNames( $testName, $pageKeys );
$xmlData = file_get_contents( $fileName );
$xmlData = $this->injectPageTitles( $xmlData, $pageTitles );
$source = new ImportStringSource( $xmlData );
$importer = $this->getImporter( $source );
$this->expectException( $exceptionName );
$this->expectExceptionMessageMatches( $exceptionMessage );
$importer->doImport();
}
}
PK ! T m m - import/ImportTemporaryUserIntegrationTest.phpnu Iw enableAutoCreateTempUser();
$this->overrideConfigValue( MainConfigNames::RCWatchCategoryMembership, true );
$referenceTime = wfTimestampNow();
ConvertibleTimestamp::setFakeTime( $referenceTime );
$this->importTestData();
$this->runJobs();
$rc = RecentChange::newFromConds( [
'rc_namespace' => NS_CATEGORY,
'rc_title' => 'Test',
'rc_source' => RecentChange::SRC_CATEGORIZE
], __METHOD__ );
$this->assertSame( '192.0.2.14', $rc->getPerformerIdentity()->getName() );
$this->assertSame( $referenceTime, $rc->getAttribute( 'rc_timestamp' ) );
}
private function importTestData(): void {
$file = __DIR__ . '/../../data/import/ImportAnonUserTest.xml';
$importStreamSource = ImportStreamSource::newFromFile( $file );
$this->assertTrue(
$importStreamSource->isGood(),
"Import source {$file} failed"
);
$importer = $this->getServiceContainer()
->getWikiImporterFactory()
->getWikiImporter( $importStreamSource->value, $this->getTestSysop()->getAuthority() );
$importer->setDebug( true );
$context = RequestContext::getMain();
$context->setUser( $this->getTestUser()->getUser() );
$reporter = new ImportReporter(
$importer,
false,
'',
false,
$context
);
$reporter->open();
$importer->doImport();
$this->assertStatusGood( $reporter->close() );
}
}
PK ! ՙd d ) import/ImportLinkCacheIntegrationTest.phpnu Iw importStreamSource = ImportStreamSource::newFromFile( $file );
if ( !$this->importStreamSource->isGood() ) {
$this->fail( "Import source for {$file} failed" );
}
}
public function testImportForImportSource() {
$this->doImport( $this->importStreamSource );
// Imported title
$loremIpsum = Title::makeTitle( NS_MAIN, 'Lorem ipsum' );
$this->assertSame(
$loremIpsum->getArticleID(),
$loremIpsum->getArticleID( IDBAccessObject::READ_LATEST )
);
$categoryLoremIpsum = Title::makeTitle( NS_CATEGORY, 'Lorem ipsum' );
$this->assertSame(
$categoryLoremIpsum->getArticleID(),
$categoryLoremIpsum->getArticleID( IDBAccessObject::READ_LATEST )
);
}
/**
* @depends testImportForImportSource
*/
public function testReImportForImportSource() {
$this->doImport( $this->importStreamSource );
// ReImported title
$loremIpsum = Title::makeTitle( NS_MAIN, 'Lorem ipsum' );
$this->assertSame(
$loremIpsum->getArticleID(),
$loremIpsum->getArticleID( IDBAccessObject::READ_LATEST )
);
$categoryLoremIpsum = Title::makeTitle( NS_CATEGORY, 'Lorem ipsum' );
$this->assertSame(
$categoryLoremIpsum->getArticleID(),
$categoryLoremIpsum->getArticleID( IDBAccessObject::READ_LATEST )
);
}
private function doImport( $importStreamSource ) {
$importer = $this->getServiceContainer()
->getWikiImporterFactory()
->getWikiImporter( $importStreamSource->value, $this->getTestSysop()->getAuthority() );
$importer->setDebug( true );
$context = RequestContext::getMain();
$context->setUser( $this->getTestUser()->getUser() );
$reporter = new ImportReporter(
$importer,
false,
'',
false,
$context
);
$reporter->open();
$importer->doImport();
$this->assertStatusGood( $reporter->close() );
}
}
PK ! Ѿ Rest/RequestFromGlobalsTest.phpnu Iw reqFromGlobals = new RequestFromGlobals();
$this->oldServer = $_SERVER;
}
protected function tearDown(): void {
$_SERVER = $this->oldServer;
parent::tearDown();
}
/**
* @dataProvider provideGetMethod
*/
public function testGetMethod( $serverVars, $expected ) {
$this->setServerVars( $serverVars );
$this->assertEquals( $expected, $this->reqFromGlobals->getMethod() );
}
public static function provideGetMethod() {
return [
[
[
'REQUEST_METHOD' => 'POST'
],
'POST',
],
[
[],
'GET',
],
[
[ 'REQUEST_METHOD' => 'get' ],
'GET',
],
];
}
public function testGetUri() {
$this->setServerVars( [
'REQUEST_URI' => '/test.php'
] );
$this->assertEquals( '/test.php', $this->reqFromGlobals->getUri() );
}
public function testGetUri2() {
$this->setServerVars( [
'REQUEST_URI' => ':8434/test.php/page/1:1',
] );
$this->assertEquals( '/test.php/page/1:1', $this->reqFromGlobals->getUri() );
}
public function testGetUri3() {
$this->setServerVars( [
'REQUEST_URI' => '/w/rest.php/sandbox.semantic-mediawiki.org:8142/v3/page/html/Berlin',
] );
$this->assertEquals(
'/w/rest.php/sandbox.semantic-mediawiki.org:8142/v3/page/html/Berlin',
$this->reqFromGlobals->getUri()
);
}
/**
* @dataProvider provideGetProtocolVersion
*/
public function testGetProtocolVersion( $serverVars, $expected ) {
$this->setServerVars( $serverVars );
$this->assertEquals( $expected, $this->reqFromGlobals->getProtocolVersion() );
}
public static function provideGetProtocolVersion() {
return [
[
[
'SERVER_PROTOCOL' => 'HTTP/2'
],
2
],
[
[],
1.1
]
];
}
public function testGetHeaders() {
$this->setServerVars( [
'HTTP_HOST' => '[::1]',
'CONTENT_LENGTH' => 6,
'CONTENT_TYPE' => 'application/json',
'CONTENT_MD5' => 'rL0Y20zC+Fzt72VPzMSk2A==',
] );
$this->assertEquals( [
'Host' => [ '[::1]' ],
'Content-Length' => [ 6 ],
'Content-Type' => [ 'application/json' ],
'Content-Md5' => [ 'rL0Y20zC+Fzt72VPzMSk2A==' ],
], $this->reqFromGlobals->getHeaders() );
}
public function testGetHeaderKeyIsCaseInsensitive() {
$cacheControl = 'private, must-revalidate, max-age=0';
$this->setServerVars( [ 'HTTP_CACHE_CONTROL' => $cacheControl ] );
$this->assertSame( [ $cacheControl ], $this->reqFromGlobals->getHeader( 'Cache-Control' ) );
$this->assertSame( [ $cacheControl ], $this->reqFromGlobals->getHeader( 'cache-control' ) );
}
public function testGetBody() {
$this->setServerVars( [
'REQUEST_METHOD' => 'POST',
'HTTP_ACCEPT' => 'text/html'
] );
$this->assertSame( '', $this->reqFromGlobals->getBody()->getContents() );
}
public function testGetServerParams() {
$serverVars = [
'SERVER_NAME' => 'www.mediawiki.org',
'SERVER_PROTOCOL' => 'HTTP/1.1',
'REQUEST_METHOD' => 'POST',
'HTTP_HOST' => 'www.mediawiki.org',
'HTTP_ACCEPT' => 'text/html',
'REMOTE_PORT' => '1234',
'SCRIPT_NAME' => '/index.php',
];
$this->setServerVars( $serverVars );
$expectedServerParams = $this->reqFromGlobals->getServerParams();
$diffs = array_diff_assoc( $expectedServerParams, $serverVars );
$this->assertCount( 2, $diffs );
$this->assertArrayHasKey( 'REQUEST_TIME_FLOAT', $diffs );
$this->assertArrayHasKey( 'REQUEST_TIME', $diffs );
}
public function testGetCookieParams() {
$_COOKIE = [
'testcookie' => true
];
$this->assertEquals( [ 'testcookie' => true ], $this->reqFromGlobals->getCookieParams() );
}
public function testGetQueryParams() {
$query = [
[
'title' => 'foo',
'action' => 'query'
]
];
$_GET = $query;
$this->assertEquals( $query, $this->reqFromGlobals->getQueryParams() );
}
public function testGetUploadedFiles() {
$_FILES = [
'file' => [
'name' => 'Foo.txt',
'type' => 'text/plain',
'tmp_name' => '/tmp/foobar',
'error' => UPLOAD_ERR_OK,
'size' => 20,
]
];
$this->assertEquals(
[
'file' => new UploadedFile(
'/tmp/foobar',
20, UPLOAD_ERR_OK,
'Foo.txt',
'text/plain'
)
],
$this->reqFromGlobals->getUploadedFiles()
);
}
public function testGetPostParams() {
$form = [
'token' => '983yh4edji',
'action' => 'login'
];
$_POST = $form;
$this->assertEquals( $form, $this->reqFromGlobals->getPostParams() );
}
protected function setServerVars( $vars ) {
// Don't remove vars which should be available in all SAPI.
if ( !isset( $vars['REQUEST_TIME_FLOAT'] ) ) {
$vars['REQUEST_TIME_FLOAT'] = $_SERVER['REQUEST_TIME_FLOAT'];
}
if ( !isset( $vars['REQUEST_TIME'] ) ) {
$vars['REQUEST_TIME'] = $_SERVER['REQUEST_TIME'];
}
$_SERVER = $vars;
}
}
PK ! 0Ny
y
Rest/EntryPointTest.phpnu Iw overrideConfigValue( MainConfigNames::RestPath, '/rest' );
}
private function createRouter( RequestInterface $request ) {
return $this->newRouter( [
'request' => $request
] );
}
/**
* @param RequestData $request
* @param MockEnvironment $env
*
* @return EntryPoint
*/
private function getEntryPoint( RequestData $request, MockEnvironment $env ): EntryPoint {
$entryPoint = new EntryPoint(
$request,
$env->makeFauxContext(),
$env,
$this->getServiceContainer()
);
$entryPoint->setRouter( $this->createRouter( $request ) );
return $entryPoint;
}
public static function mockHandlerHeader() {
return new class extends Handler {
public function execute() {
$response = $this->getResponseFactory()->create();
$response->setHeader( 'Foo', 'Bar' );
return $response;
}
};
}
public function testHeader() {
$uri = '/rest/mock/v1/EntryPoint/header';
$request = new RequestData( [ 'uri' => new Uri( $uri ) ] );
$env = new MockEnvironment();
$env->setRequestInfo( $uri );
$entryPoint = $this->getEntryPoint(
$request,
$env
);
$entryPoint->enableOutputCapture();
$entryPoint->run();
$env->assertHeaderValue( 'Bar', 'Foo' );
$env->assertStatusCode( 200 );
}
public static function mockHandlerBodyRewind() {
return new class extends Handler {
public function execute() {
$response = $this->getResponseFactory()->create();
$stream = new Stream( fopen( 'php://memory', 'w+' ) );
$stream->write( 'hello' );
$response->setBody( $stream );
return $response;
}
};
}
/**
* Make sure EntryPoint rewinds a seekable body stream before reading.
*/
public function testBodyRewind() {
$uri = '/rest/mock/v1/EntryPoint/bodyRewind';
$request = new RequestData( [ 'uri' => new Uri( $uri ) ] );
$env = new MockEnvironment();
$env->setRequestInfo( $uri );
$entryPoint = $this->getEntryPoint(
$request,
$env
);
$entryPoint->enableOutputCapture();
$entryPoint->run();
// NOTE: MediaWikiEntryPoint::doPostOutputShutdown flushes all output buffers
$this->assertStringContainsString( 'hello', $entryPoint->getCapturedOutput() );
}
}
PK ! UGJ J % Storage/NameTableStoreFactoryTest.phpnu Iw createMock( ILoadBalancer::class );
$mock->method( 'getLocalDomainID' )
->willReturn( $localDomain );
return $mock;
}
/**
* @param string $expectedWiki
* @return MockObject|ILBFactory
*/
private function getMockLoadBalancerFactory( $expectedWiki ) {
$mock = $this->createMock( ILBFactory::class );
$lbFactory = $this->getServiceContainer()->getDBLoadBalancerFactory();
$localDomain = $lbFactory->getLocalDomainID();
$mock->method( 'getLocalDomainID' )->willReturn( $localDomain );
$mock->expects( $this->once() )
->method( 'getMainLB' )
->with( $expectedWiki )
->willReturnCallback( function ( $domain ) use ( $localDomain ) {
return $this->getMockLoadBalancer( $localDomain );
} );
return $mock;
}
public static function provideTestGet() {
return [
[
'change_tag_def',
false,
false,
],
[
'content_models',
false,
false,
],
[
'slot_roles',
false,
false,
],
[
'change_tag_def',
'test7245',
'test7245',
],
];
}
/** @dataProvider provideTestGet */
public function testGet( $tableName, $wiki, $expectedWiki ) {
$services = $this->getServiceContainer();
$wiki2 = ( $wiki === false )
? $services->getDBLoadBalancerFactory()->getLocalDomainID()
: $wiki;
$names = new NameTableStoreFactory(
$this->getMockLoadBalancerFactory( $expectedWiki ),
$services->getMainWANObjectCache(),
LoggerFactory::getInstance( 'NameTableStoreFactory' )
);
$table = $names->get( $tableName, $wiki );
$table2 = $names->get( $tableName, $wiki2 );
$this->assertSame( $table, $table2 );
$this->assertInstanceOf( NameTableStore::class, $table );
}
/*
* The next three integration tests verify that the schema information is correct by loading
* the relevant information from the database.
*/
public function testIntegratedGetChangeTagDef() {
$services = $this->getServiceContainer();
$factory = $services->getNameTableStoreFactory();
$store = $factory->getChangeTagDef();
$this->assertIsArray( $store->getMap() );
}
public function testIntegratedGetContentModels() {
$services = $this->getServiceContainer();
$factory = $services->getNameTableStoreFactory();
$store = $factory->getContentModels();
$this->assertIsArray( $store->getMap() );
}
public function testIntegratedGetSlotRoles() {
$services = $this->getServiceContainer();
$factory = $services->getNameTableStoreFactory();
$store = $factory->getSlotRoles();
$this->assertIsArray( $store->getMap() );
}
}
PK ! ï- - Storage/PageUpdaterTest.phpnu Iw getServiceContainer()->getSlotRoleRegistry();
if ( !$slotRoleRegistry->isDefinedRole( 'aux' ) ) {
$slotRoleRegistry->defineRoleWithModel(
'aux',
CONTENT_MODEL_WIKITEXT
);
}
if ( !$slotRoleRegistry->isDefinedRole( 'derivedslot' ) ) {
$slotRoleRegistry->defineRoleWithModel(
'derivedslot',
CONTENT_MODEL_WIKITEXT,
[],
true
);
}
}
private function getDummyTitle( $method ) {
return Title::newFromText( $method, $this->getDefaultWikitextNS() );
}
/**
* @param int $revId
*
* @return null|RecentChange
*/
private function getRecentChangeFor( $revId ) {
$qi = RecentChange::getQueryInfo();
$row = $this->getDb()->newSelectQueryBuilder()
->queryInfo( $qi )
->where( [ 'rc_this_oldid' => $revId ] )
->caller( __METHOD__ )
->fetchRow();
return $row ? RecentChange::newFromRow( $row ) : null;
}
/**
* @covers \MediaWiki\Storage\PageUpdater::saveRevision()
* @covers \WikiPage::newPageUpdater()
*/
public function testCreatePage() {
$user = $this->getTestUser()->getUser();
$wikiPageFactory = $this->getServiceContainer()->getWikiPageFactory();
$title = $this->getDummyTitle( __METHOD__ );
$page = $wikiPageFactory->newFromTitle( $title );
$updater = $page->newPageUpdater( $user );
$oldStats = $this->getDb()->newSelectQueryBuilder()
->select( '*' )
->from( 'site_stats' )
->where( '1=1' )
->fetchRow();
$this->assertFalse( $updater->wasCommitted(), 'wasCommitted' );
$updater->addTag( 'foo' );
$updater->addTags( [ 'bar', 'qux' ] );
$tags = $updater->getExplicitTags();
sort( $tags );
$this->assertSame( [ 'bar', 'foo', 'qux' ], $tags, 'getExplicitTags' );
// TODO: MCR: test additional slots
$content = new TextContent( 'Lorem Ipsum' );
$updater->setContent( SlotRecord::MAIN, $content );
$parent = $updater->grabParentRevision();
$this->assertNull( $parent, 'getParentRevision' );
$this->assertFalse( $updater->wasCommitted(), 'wasCommitted' );
// TODO: test that hasEditConflict() grabs the parent revision
$this->assertFalse( $updater->hasEditConflict( 0 ), 'hasEditConflict' );
$this->assertTrue( $updater->hasEditConflict( 1 ), 'hasEditConflict' );
// TODO: test failure with EDIT_UPDATE
// TODO: test EDIT_BOT, etc
$updater->setFlags( EDIT_MINOR );
$summary = CommentStoreComment::newUnsavedComment( 'Just a test' );
$rev = $updater->saveRevision( $summary );
$this->assertNotNull( $rev );
$this->assertSame( 0, $rev->getParentId() );
$this->assertSame( $summary->text, $rev->getComment( RevisionRecord::RAW )->text );
$this->assertSame( $user->getName(), $rev->getUser( RevisionRecord::RAW )->getName() );
$this->assertTrue( $updater->wasCommitted(), 'wasCommitted()' );
$this->assertTrue( $updater->wasSuccessful(), 'wasSuccessful()' );
$this->assertTrue( $updater->getStatus()->isOK(), 'getStatus()->isOK()' );
$this->assertTrue( $updater->isNew(), 'isNew()' );
$this->assertTrue( $updater->wasRevisionCreated(), 'wasRevisionCreated()' );
$this->assertNotNull( $updater->getNewRevision(), 'getNewRevision()' );
$this->assertInstanceOf(
RevisionRecord::class,
$updater->getStatus()->getNewRevision()
);
// check the EditResult object
$this->assertFalse( $updater->getEditResult()->getOriginalRevisionId(),
'EditResult::getOriginalRevisionId()' );
$this->assertSame( 0, $updater->getEditResult()->getUndidRevId(),
'EditResult::getUndidRevId()' );
$this->assertTrue( $updater->getEditResult()->isNew(), 'EditResult::isNew()' );
$this->assertFalse( $updater->getEditResult()->isRevert(), 'EditResult::isRevert()' );
$rev = $updater->getNewRevision();
$revContent = $rev->getContent( SlotRecord::MAIN );
$this->assertSame( 'Lorem Ipsum', $revContent->serialize(), 'revision content' );
$this->assertTrue( $rev->isMinor(), 'RevisionRecord::isMinor()' );
// were the WikiPage and Title objects updated?
$this->assertTrue( $page->exists(), 'WikiPage::exists()' );
$this->assertTrue( $title->exists(), 'Title::exists()' );
$this->assertSame( $rev->getId(), $page->getLatest(), 'WikiPage::getLatest()' );
$this->assertNotNull( $page->getRevisionRecord(), 'WikiPage::getRevisionRecord()' );
// re-load
$page2 = $wikiPageFactory->newFromTitle( $title );
$this->assertTrue( $page2->exists(), 'WikiPage::exists()' );
$this->assertSame( $rev->getId(), $page2->getLatest(), 'WikiPage::getLatest()' );
$this->assertNotNull( $page2->getRevisionRecord(), 'WikiPage::getRevisionRecord()' );
// Check RC entry
$rc = $this->getRecentChangeFor( $rev->getId() );
$this->assertNotNull( $rc, 'RecentChange' );
// check site stats - this asserts that derived data updates where run.
$stats = $this->getDb()->newSelectQueryBuilder()
->select( '*' )
->from( 'site_stats' )
->where( '1=1' )
->fetchRow();
$this->assertSame( $oldStats->ss_total_pages + 1, (int)$stats->ss_total_pages );
$this->assertSame( $oldStats->ss_total_edits + 1, (int)$stats->ss_total_edits );
// re-edit with same content - should be a "null-edit"
$updater = $page->newPageUpdater( $user )
->setContent( SlotRecord::MAIN, $content );
$summary = CommentStoreComment::newUnsavedComment( 're-edit' );
$rev = $updater->saveRevision( $summary );
$status = $updater->getStatus();
$this->assertNull( $rev, 'getNewRevision()' );
$this->assertNull( $updater->getNewRevision(), 'getNewRevision()' );
$this->assertFalse( $updater->wasRevisionCreated(), 'wasRevisionCreated' );
$this->assertTrue( $updater->wasSuccessful(), 'wasSuccessful()' );
$this->assertStatusWarning( 'edit-no-change', $status );
}
/**
* @covers \MediaWiki\Storage\PageUpdater::saveRevision()
* @covers \WikiPage::newPageUpdater()
*/
public function testUpdatePage() {
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
$this->insertPage( $title );
$wikiPageFactory = $this->getServiceContainer()->getWikiPageFactory();
$page = $wikiPageFactory->newFromTitle( $title );
$parentId = $page->getLatest();
$updater = $page->newPageUpdater( $user );
$oldStats = $this->getDb()->newSelectQueryBuilder()
->select( '*' )
->from( 'site_stats' )
->where( '1=1' )
->fetchRow();
$updater->setOriginalRevisionId( 7 );
$this->assertFalse( $updater->hasEditConflict( $parentId ), 'hasEditConflict' );
$this->assertTrue( $updater->hasEditConflict( $parentId - 1 ), 'hasEditConflict' );
$this->assertTrue( $updater->hasEditConflict( 0 ), 'hasEditConflict' );
// TODO: MCR: test additional slots
$updater->setContent( SlotRecord::MAIN, new TextContent( 'Lorem Ipsum' ) );
// Check that prepareUpdate() does not fail, and the flag is applied.
$updater->prepareUpdate( EDIT_MINOR );
// TODO: test all flags for saveRevision()!
$summary = CommentStoreComment::newUnsavedComment( 'Just a test' );
$rev = $updater->saveRevision( $summary );
$this->assertNotNull( $rev );
$this->assertSame( $parentId, $rev->getParentId() );
$this->assertSame( $summary->text, $rev->getComment( RevisionRecord::RAW )->text );
$this->assertSame( $user->getName(), $rev->getUser( RevisionRecord::RAW )->getName() );
$this->assertTrue( $updater->wasCommitted(), 'wasCommitted()' );
$this->assertTrue( $updater->wasSuccessful(), 'wasSuccessful()' );
$this->assertTrue( $updater->getStatus()->isOK(), 'getStatus()->isOK()' );
$this->assertFalse( $updater->isNew(), 'isNew()' );
$this->assertNotNull( $updater->getNewRevision(), 'getNewRevision()' );
$this->assertInstanceOf(
RevisionRecord::class,
$updater->getStatus()->getNewRevision()
);
$this->assertTrue( $updater->wasRevisionCreated(), 'wasRevisionCreated()' );
// check the EditResult object
$this->assertSame( 7, $updater->getEditResult()->getOriginalRevisionId(),
'EditResult::getOriginalRevisionId()' );
$this->assertSame( 0, $updater->getEditResult()->getUndidRevId(),
'EditResult::getUndidRevId()' );
$this->assertFalse( $updater->getEditResult()->isNew(), 'EditResult::isNew()' );
$this->assertFalse( $updater->getEditResult()->isRevert(), 'EditResult::isRevert()' );
// TODO: Test null revision (with different user): new revision!
$rev = $updater->getNewRevision();
$revContent = $rev->getContent( SlotRecord::MAIN );
$this->assertSame( 'Lorem Ipsum', $revContent->serialize(), 'revision content' );
$this->assertTrue( $rev->isMinor(), 'RevisionRecord::isMinor()' );
// were the WikiPage and Title objects updated?
$this->assertTrue( $page->exists(), 'WikiPage::exists()' );
$this->assertTrue( $title->exists(), 'Title::exists()' );
$this->assertSame( $rev->getId(), $page->getLatest(), 'WikiPage::getLatest()' );
$this->assertNotNull( $page->getRevisionRecord(), 'WikiPage::getRevisionRecord()' );
// re-load
$page2 = $wikiPageFactory->newFromTitle( $title );
$this->assertTrue( $page2->exists(), 'WikiPage::exists()' );
$this->assertSame( $rev->getId(), $page2->getLatest(), 'WikiPage::getLatest()' );
$this->assertNotNull( $page2->getRevisionRecord(), 'WikiPage::getRevisionRecord()' );
// Check RC entry
$rc = $this->getRecentChangeFor( $rev->getId() );
$this->assertNotNull( $rc, 'RecentChange' );
// re-edit
$updater = $page->newPageUpdater( $user )
->setContent( SlotRecord::MAIN, new TextContent( 'dolor sit amet' ) );
$summary = CommentStoreComment::newUnsavedComment( 're-edit' );
$updater->saveRevision( $summary );
$this->assertTrue( $updater->wasSuccessful(), 'wasSuccessful()' );
$this->assertTrue( $updater->getStatus()->isOK(), 'getStatus()->isOK()' );
$this->assertNotNull( $updater->getNewRevision(), 'getNewRevision()' );
$topRevisionId = $updater->getNewRevision()->getId();
// perform a null edit
$updater = $page->newPageUpdater( $user )
->setContent( SlotRecord::MAIN, new TextContent( 'dolor sit amet' ) );
$summary = CommentStoreComment::newUnsavedComment( 'null edit' );
$updater->saveRevision( $summary );
$this->assertTrue( $updater->wasSuccessful(), 'wasSuccessful()' );
$this->assertTrue( $updater->getStatus()->isOK(), 'getStatus()->isOK()' );
$this->assertFalse( $updater->wasRevisionCreated(), 'wasRevisionCreated()' );
$this->assertTrue(
$updater->getEditResult()->isNullEdit(),
'getEditResult()->isNullEdit()'
);
$this->assertSame(
$topRevisionId,
$updater->getEditResult()->getOriginalRevisionId(),
'getEditResult()->getOriginalRevisionId()'
);
// check site stats - this asserts that derived data updates where run.
$stats = $this->getDb()->newSelectQueryBuilder()
->select( '*' )
->from( 'site_stats' )
->where( '1=1' )
->fetchRow();
$this->assertNotNull( $stats, 'site_stats' );
$this->assertSame( $oldStats->ss_total_pages + 0, (int)$stats->ss_total_pages );
$this->assertSame( $oldStats->ss_total_edits + 2, (int)$stats->ss_total_edits );
}
public function testSetForceEmptyRevisionSetsOriginalRevisionId() {
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
$this->insertPage( $title );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$parentId = $page->getLatest();
$updater = $page->newPageUpdater( $user );
$updater->setForceEmptyRevision( true );
// Saving without changing the content should now create a new revisiopns
$summary = CommentStoreComment::newUnsavedComment( 'dummy revision' );
$rev = $updater->saveRevision( $summary );
$status = $updater->getStatus();
$this->assertNotNull( $rev, 'getNewRevision()' );
$this->assertNotNull( $updater->getNewRevision(), 'getNewRevision()' );
$this->assertNotSame( $parentId, $rev->getId(), 'new revision ID' );
$this->assertTrue( $updater->wasRevisionCreated(), 'wasRevisionCreated' );
$this->assertTrue( $updater->wasSuccessful(), 'wasSuccessful()' );
$this->assertStatusGood( $status );
// Setting setForceEmptyRevision causes the original revision to be set.
$this->assertEquals( $parentId, $updater->getEditResult()->getOriginalRevisionId() );
}
public function testSetForceEmptyRevisionCausesSaveToFailWithChangedContent() {
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
$this->insertPage( $title );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$updater = $page->newPageUpdater( $user );
$updater->setForceEmptyRevision( true );
// Setting setForceEmptyRevision causes saveRevision() to fail if the content is changed.
// The positive case with setForceEmptyRevision() causing a new revision to be created
// is tested
$this->expectException( LogicException::class );
$updater->setContent( SlotRecord::MAIN, new TextContent( 'Changed Content' ) );
$summary = CommentStoreComment::newUnsavedComment( 'dummy revision' );
$updater->saveRevision( $summary );
}
public function testRevert() {
// Setup a page with some edits
$page = $this->getExistingTestPage( __METHOD__ );
$user = $this->getTestUser()->getUser();
$summary = CommentStoreComment::newUnsavedComment( '1' );
$updater = $page->newPageUpdater( $user )
->setContent( SlotRecord::MAIN, new TextContent( '1' ) );
$updater->saveRevision( $summary );
$revId1 = $updater->getNewRevision()->getId();
$summary = CommentStoreComment::newUnsavedComment( '2' );
$updater = $page->newPageUpdater( $user )
->setContent( SlotRecord::MAIN, new TextContent( '2' ) );
$updater->saveRevision( $summary );
$revId2 = $updater->getNewRevision()->getId();
// Perform a rollback
$updater = $page->newPageUpdater( $this->getTestSysop()->getUser() )
->setContent( SlotRecord::MAIN, new TextContent( '1' ) )
->markAsRevert( EditResult::REVERT_ROLLBACK, $revId2, $revId1 );
$summary = CommentStoreComment::newUnsavedComment( 'revert' );
$updater->saveRevision( $summary );
// Do some basic assertions on PageUpdater
$this->assertTrue( $updater->wasSuccessful(), 'wasSuccessful()' );
$this->assertTrue( $updater->getStatus()->isOK(), 'getStatus()->isOK()' );
$editResult = $updater->getEditResult();
$this->assertNotNull( $editResult, 'getEditResult()' );
$this->assertTrue( $editResult->isRevert(), 'EditResult::isRevert()' );
$this->assertTrue( $editResult->isExactRevert(), 'EditResult::isExactRevert()' );
$this->assertSame(
$revId1,
$editResult->getOriginalRevisionId(),
'EditResult::getOriginalRevisionId()'
);
$this->assertSame(
EditResult::REVERT_ROLLBACK,
$editResult->getRevertMethod(),
'EditResult::getRevertMethod()'
);
$this->assertSame(
$revId2,
$editResult->getOldestRevertedRevisionId(),
'EditResult::getOldestRevertedRevisionId()'
);
$this->assertSame(
$revId2,
$editResult->getNewestRevertedRevisionId(),
'EditResult::getNewestRevertedRevisionId()'
);
// Ensure all deferred updates are run
DeferredUpdates::doUpdates();
// Retrieve the mw-rollback change tag and verify it
$newRevId = $updater->getNewRevision()->getId();
$this->newSelectQueryBuilder()
->select( 'ct_params' )
->from( 'change_tag' )
->where( [ 'ct_rev_id' => $newRevId ] )
->assertFieldValue( FormatJson::encode( $editResult ) );
}
/**
* Creates a revision in the database.
*
* @param WikiPage $page
* @param string|Message|CommentStoreComment $summary
* @param null|string|Content $content
*
* @return RevisionRecord|null
*/
private function createRevision( WikiPage $page, $summary, $content = null ) {
$user = $this->getTestUser()->getUser();
$comment = CommentStoreComment::newUnsavedComment( $summary );
if ( !$content instanceof Content ) {
$content = new TextContent( $content ?? $summary );
}
return $page->newPageUpdater( $user )
->setContent( SlotRecord::MAIN, $content )
->saveRevision( $comment );
}
/**
* Verify that MultiContentSave hook is called by saveRevision() with correct parameters.
* @covers \MediaWiki\Storage\PageUpdater::saveRevision()
*/
public function testMultiContentSaveHook() {
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
// TODO: MCR: test additional slots
$slots = [
SlotRecord::MAIN => new TextContent( 'Lorem Ipsum' )
];
// start editing non-existing page
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$updater = $page->newPageUpdater( $user );
foreach ( $slots as $slot => $content ) {
$updater->setContent( $slot, $content );
}
$summary = CommentStoreComment::newUnsavedComment( 'Just a test' );
$expected = [
'user' => $user,
'title' => $title,
'slots' => $slots,
'summary' => $summary
];
$hookFired = false;
$this->setTemporaryHook( 'MultiContentSave',
function ( RenderedRevision $renderedRevision, UserIdentity $user,
$summary, $flags, Status $hookStatus
) use ( &$hookFired, $expected ) {
$hookFired = true;
$this->assertSame( $expected['summary'], $summary );
$this->assertSame( EDIT_NEW, $flags );
$this->assertTrue(
$expected['title']->isSamePageAs( $renderedRevision->getRevision()->getPage() )
);
$this->assertTrue(
$expected['title']->isSameLinkAs( $renderedRevision->getRevision()->getPageAsLinkTarget() )
);
$slots = $renderedRevision->getRevision()->getSlots();
foreach ( $expected['slots'] as $slot => $content ) {
$this->assertSame( $content, $slots->getSlot( $slot )->getContent() );
}
// Don't abort this edit.
return true;
}
);
$rev = $updater->saveRevision( $summary );
$this->assertTrue( $hookFired, "MultiContentSave hook wasn't called." );
$this->assertNotNull( $rev,
"MultiContentSave returned true, but revision wasn't created." );
}
/**
* Verify that MultiContentSave hook can abort saveRevision() by returning false.
* @covers \MediaWiki\Storage\PageUpdater::saveRevision()
*/
public function testMultiContentSaveHookAbort() {
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
// start editing non-existing page
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$updater = $page->newPageUpdater( $user )
->setContent( SlotRecord::MAIN, new TextContent( 'Lorem Ipsum' ) );
$summary = CommentStoreComment::newUnsavedComment( 'Just a test' );
$expectedError = 'aborted-by-test-hook';
$this->setTemporaryHook( 'MultiContentSave',
static function ( RenderedRevision $renderedRevision, UserIdentity $user,
$summary, $flags, Status $hookStatus
) use ( $expectedError ) {
$hookStatus->fatal( $expectedError );
// Returning false should disallow saveRevision() to continue saving this revision.
return false;
}
);
$rev = $updater->saveRevision( $summary );
$this->assertNull( $rev,
"MultiContentSave returned false, but revision was still created." );
$status = $updater->getStatus();
$this->assertStatusError( $expectedError, $status,
"MultiContentSave returned false, but Status is not fatal." );
}
/**
* @covers \MediaWiki\Storage\PageUpdater::grabParentRevision()
* @covers \MediaWiki\Storage\PageUpdater::saveRevision()
*/
public function testCompareAndSwapFailure() {
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
$wikiPageFactory = $this->getServiceContainer()->getWikiPageFactory();
// start editing non-existing page
$page = $wikiPageFactory->newFromTitle( $title );
$updater = $page->newPageUpdater( $user );
$updater->grabParentRevision();
// create page concurrently
$concurrentPage = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$this->createRevision( $concurrentPage, __METHOD__ . '-one' );
// try creating the page - should trigger CAS failure.
$summary = CommentStoreComment::newUnsavedComment( 'create?!' );
$updater->setContent( SlotRecord::MAIN, new TextContent( 'Lorem ipsum' ) );
$updater->saveRevision( $summary );
$status = $updater->getStatus();
$this->assertFalse( $updater->wasSuccessful(), 'wasSuccessful()' );
$this->assertNull( $updater->getNewRevision(), 'getNewRevision()' );
$this->assertStatusError( 'edit-already-exists', $status, 'edit-conflict' );
// start editing existing page
$page = $wikiPageFactory->newFromTitle( $title );
$updater = $page->newPageUpdater( $user );
$updater->grabParentRevision();
// update page concurrently
$concurrentPage = $wikiPageFactory->newFromTitle( $title );
$this->createRevision( $concurrentPage, __METHOD__ . '-two' );
// try creating the page - should trigger CAS failure.
$summary = CommentStoreComment::newUnsavedComment( 'edit?!' );
$updater->setContent( SlotRecord::MAIN, new TextContent( 'dolor sit amet' ) );
$updater->saveRevision( $summary );
$status = $updater->getStatus();
$this->assertFalse( $updater->wasSuccessful(), 'wasSuccessful()' );
$this->assertNull( $updater->getNewRevision(), 'getNewRevision()' );
$this->assertStatusError( 'edit-conflict', $status, 'edit-conflict' );
}
/**
* @covers \MediaWiki\Storage\PageUpdater::saveRevision()
*/
public function testFailureOnEditFlags() {
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
// start editing non-existing page
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$updater = $page->newPageUpdater( $user );
// update with EDIT_UPDATE flag should fail
$summary = CommentStoreComment::newUnsavedComment( 'udpate?!' );
$updater->setContent( SlotRecord::MAIN, new TextContent( 'Lorem ipsum' ) );
$updater->saveRevision( $summary, EDIT_UPDATE );
$status = $updater->getStatus();
$this->assertFalse( $updater->wasSuccessful(), 'wasSuccessful()' );
$this->assertNull( $updater->getNewRevision(), 'getNewRevision()' );
$this->assertStatusError( 'edit-gone-missing', $status, 'edit-gone-missing' );
// create the page
$this->createRevision( $page, __METHOD__ );
// update with EDIT_NEW flag should fail
$summary = CommentStoreComment::newUnsavedComment( 'create?!' );
$updater = $page->newPageUpdater( $user )
->setContent( SlotRecord::MAIN, new TextContent( 'dolor sit amet' ) );
$updater->saveRevision( $summary, EDIT_NEW );
$status = $updater->getStatus();
$this->assertFalse( $updater->wasSuccessful(), 'wasSuccessful()' );
$this->assertNull( $updater->getNewRevision(), 'getNewRevision()' );
$this->assertStatusError( 'edit-already-exists', $status, 'edit-already-exists' );
}
/**
* @covers \MediaWiki\Storage\PageUpdater::saveRevision()
*/
public function testFailureOnBadContentModel() {
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
// start editing non-existing page
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
// plain text content should fail in aux slot (the main slot doesn't care)
$updater = $page->newPageUpdater( $user )
->setContent( SlotRecord::MAIN, new TextContent( 'Main Content' ) )
->setContent( 'aux', new TextContent( 'Aux Content' ) );
$summary = CommentStoreComment::newUnsavedComment( 'udpate?!' );
$updater->saveRevision( $summary, EDIT_UPDATE );
$status = $updater->getStatus();
$this->assertFalse( $updater->wasSuccessful(), 'wasSuccessful()' );
$this->assertNull( $updater->getNewRevision(), 'getNewRevision()' );
$this->assertStatusError( 'content-not-allowed-here', $status );
}
public static function provideSetRcPatrolStatus( $patrolled ) {
yield [ RecentChange::PRC_UNPATROLLED ];
yield [ RecentChange::PRC_AUTOPATROLLED ];
}
/**
* @dataProvider provideSetRcPatrolStatus
* @covers \MediaWiki\Storage\PageUpdater::setRcPatrolStatus()
*/
public function testSetRcPatrolStatus( $patrolled ) {
$revisionStore = $this->getServiceContainer()->getRevisionStore();
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$summary = CommentStoreComment::newUnsavedComment( 'Lorem ipsum ' . $patrolled );
$rev = $page->newPageUpdater( $user )
->setContent( SlotRecord::MAIN, new TextContent( 'Lorem ipsum ' . $patrolled ) )
->setRcPatrolStatus( $patrolled )
->saveRevision( $summary );
$rc = $revisionStore->getRecentChange( $rev );
$this->assertEquals( $patrolled, $rc->getAttribute( 'rc_patrolled' ) );
}
/**
* @covers \MediaWiki\Storage\PageUpdater::makeNewRevision()
*/
public function testStalePageID() {
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
$summary = CommentStoreComment::newUnsavedComment( 'testing...' );
$wikiPageFactory = $this->getServiceContainer()->getWikiPageFactory();
// Create page
$page = $wikiPageFactory->newFromTitle( $title );
$updater = $page->newPageUpdater( $user )
->setContent( SlotRecord::MAIN, new TextContent( 'Content 1' ) );
$updater->saveRevision( $summary, EDIT_NEW );
$this->assertTrue( $updater->wasSuccessful(), 'wasSuccessful()' );
// Create a clone of $title and $page.
$title = Title::makeTitle( $title->getNamespace(), $title->getDBkey() );
$page = $wikiPageFactory->newFromTitle( $title );
// start editing existing page using bad page ID
$updater = $page->newPageUpdater( $user );
$updater->grabParentRevision();
$updater->setContent( SlotRecord::MAIN, new TextContent( 'Content 2' ) );
// Force the article ID to something invalid,
// to emulate confusion due to a page move.
$title->resetArticleID( 886655 );
@$updater->saveRevision( $summary, EDIT_UPDATE );
$this->assertTrue( $updater->wasSuccessful(), 'wasSuccessful()' );
}
/**
* @covers \MediaWiki\Storage\PageUpdater::inheritSlot()
* @covers \MediaWiki\Storage\PageUpdater::setContent()
*/
public function testInheritSlot() {
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$updater = $page->newPageUpdater( $user );
$summary = CommentStoreComment::newUnsavedComment( 'one' );
$updater->setContent( SlotRecord::MAIN, new TextContent( 'Lorem ipsum' ) );
$rev1 = $updater->saveRevision( $summary, EDIT_NEW );
$updater = $page->newPageUpdater( $user );
$summary = CommentStoreComment::newUnsavedComment( 'two' );
$updater->setContent( SlotRecord::MAIN, new TextContent( 'Foo Bar' ) );
$rev2 = $updater->saveRevision( $summary, EDIT_UPDATE );
$updater = $page->newPageUpdater( $user );
$summary = CommentStoreComment::newUnsavedComment( 'three' );
$updater->inheritSlot( $rev1->getSlot( SlotRecord::MAIN ) );
$rev3 = $updater->saveRevision( $summary, EDIT_UPDATE );
$this->assertNotSame( $rev1->getId(), $rev3->getId() );
$this->assertNotSame( $rev2->getId(), $rev3->getId() );
$main1 = $rev1->getSlot( SlotRecord::MAIN );
$main3 = $rev3->getSlot( SlotRecord::MAIN );
$this->assertNotSame( $main1->getRevision(), $main3->getRevision() );
$this->assertSame( $main1->getAddress(), $main3->getAddress() );
$this->assertTrue( $main1->getContent()->equals( $main3->getContent() ) );
}
/**
* @covers \MediaWiki\Storage\PageUpdater::setSlot()
* @covers \MediaWiki\Storage\PageUpdater::updateRevision()
*/
public function testUpdatingDerivedSlot() {
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$updater = $page->newPageUpdater( $user );
$summary = CommentStoreComment::newUnsavedComment( 'one' );
$updater->setContent( SlotRecord::MAIN, new TextContent( 'Lorem ipsum' ) );
$updater->saveRevision( $summary, EDIT_NEW );
$updater = $page->newPageUpdater( $user );
$content = new WikitextContent( 'A' );
$derived = SlotRecord::newDerived( 'derivedslot', $content );
$updater->setSlot( $derived );
$updater->updateRevision();
$status = $updater->getStatus();
$this->assertStatusGood( $status );
$rev = $status->getNewRevision();
$slot = $rev->getSlot( 'derivedslot' );
$this->assertTrue( $slot->getContent()->equals( $content ) );
}
/**
* @covers \MediaWiki\Storage\PageUpdater::setSlot()
* @covers \MediaWiki\Storage\PageUpdater::updateRevision()
*/
public function testUpdatingDerivedSlotCurrentRevision() {
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$updater = $page->newPageUpdater( $user );
$summary = CommentStoreComment::newUnsavedComment( 'one' );
$updater->setContent( SlotRecord::MAIN, new TextContent( 'Lorem ipsum' ) );
$rev1 = $updater->saveRevision( $summary, EDIT_NEW );
$updater = $page->newPageUpdater( $user );
$content = new WikitextContent( 'A' );
$derived = SlotRecord::newDerived( 'derivedslot', $content );
$updater->setSlot( $derived );
$updater->updateRevision( $rev1->getId( $rev1->getWikiId() ) );
$rev2 = $updater->getStatus()->getNewRevision();
$slot = $rev2->getSlot( 'derivedslot' );
$this->assertTrue( $slot->getContent()->equals( $content ) );
}
/**
* @covers \MediaWiki\Storage\PageUpdater::setSlot()
* @covers \MediaWiki\Storage\PageUpdater::updateRevision()
*/
public function testUpdatingDerivedSlotOldRevision() {
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$updater = $page->newPageUpdater( $user );
$summary = CommentStoreComment::newUnsavedComment( 'one' );
$updater->setContent( SlotRecord::MAIN, new TextContent( 'Lorem ipsum' ) );
$rev1 = $updater->saveRevision( $summary, EDIT_NEW );
$updater = $page->newPageUpdater( $user );
$summary = CommentStoreComment::newUnsavedComment( 'two' );
$updater->setContent( SlotRecord::MAIN, new TextContent( 'Something different' ) );
$updater->saveRevision( $summary, EDIT_UPDATE );
$updater = $page->newPageUpdater( $user );
$content = new WikitextContent( 'A' );
$derived = SlotRecord::newDerived( 'derivedslot', $content );
$updater->setSlot( $derived );
$updater->updateRevision( $rev1->getId( $rev1->getWikiId() ) );
$rev3 = $updater->getStatus()->getNewRevision();
$slot = $rev3->getSlot( 'derivedslot' );
$this->assertTrue( $slot->getContent()->equals( $content ) );
}
// TODO: MCR: test adding multiple slots, inheriting parent slots, and removing slots.
public function testSetUseAutomaticEditSummaries() {
$this->setContentLang( 'qqx' );
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
$wikiPageFactory = $this->getServiceContainer()->getWikiPageFactory();
$page = $wikiPageFactory->newFromTitle( $title );
$updater = $page->newPageUpdater( $user )
->setUseAutomaticEditSummaries( true )
->setContent( SlotRecord::MAIN, new TextContent( 'Lorem Ipsum' ) );
// empty comment triggers auto-summary
$summary = CommentStoreComment::newUnsavedComment( '' );
$updater->saveRevision( $summary, EDIT_AUTOSUMMARY );
$rev = $updater->getNewRevision();
$comment = $rev->getComment( RevisionRecord::RAW );
$this->assertSame( '(autosumm-new: Lorem Ipsum)', $comment->text, 'comment text' );
// check that this also works when blanking the page
$updater = $page->newPageUpdater( $user )
->setUseAutomaticEditSummaries( true )
->setContent( SlotRecord::MAIN, new TextContent( '' ) );
$summary = CommentStoreComment::newUnsavedComment( '' );
$updater->saveRevision( $summary, EDIT_AUTOSUMMARY );
$rev = $updater->getNewRevision();
$comment = $rev->getComment( RevisionRecord::RAW );
$this->assertSame( '(autosumm-blank)', $comment->text, 'comment text' );
// check that we can also disable edit-summaries
$title2 = $this->getDummyTitle( __METHOD__ . '/2' );
$page2 = $wikiPageFactory->newFromTitle( $title2 );
$updater = $page2->newPageUpdater( $user )
->setUseAutomaticEditSummaries( false )
->setContent( SlotRecord::MAIN, new TextContent( 'Lorem Ipsum' ) );
$summary = CommentStoreComment::newUnsavedComment( '' );
$updater->saveRevision( $summary, EDIT_AUTOSUMMARY );
$rev = $updater->getNewRevision();
$comment = $rev->getComment( RevisionRecord::RAW );
$this->assertSame( '', $comment->text, 'comment text should still be blank' );
// check that we don't do auto.summaries without the EDIT_AUTOSUMMARY flag
$updater = $page2->newPageUpdater( $user )
->setUseAutomaticEditSummaries( true )
->setContent( SlotRecord::MAIN, new TextContent( '' ) );
$summary = CommentStoreComment::newUnsavedComment( '' );
$updater->saveRevision( $summary, 0 );
$rev = $updater->getNewRevision();
$comment = $rev->getComment( RevisionRecord::RAW );
$this->assertSame( '', $comment->text, 'comment text' );
}
public static function provideSetUsePageCreationLog() {
yield [ true, [ [ 'create', 'create' ] ] ];
yield [ false, [] ];
}
/**
* @dataProvider provideSetUsePageCreationLog
*/
public function testSetUsePageCreationLog( $use, $expected ) {
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ . ( $use ? '_logged' : '_unlogged' ) );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$summary = CommentStoreComment::newUnsavedComment( 'cmt' );
$updater = $page->newPageUpdater( $user )
->setUsePageCreationLog( $use )
->setContent( SlotRecord::MAIN, new TextContent( 'Lorem Ipsum' ) );
$updater->saveRevision( $summary, EDIT_NEW );
$rev = $updater->getNewRevision();
$this->newSelectQueryBuilder()
->select( [ 'log_type', 'log_action' ] )
->from( 'logging' )
->where( [ 'log_page' => $rev->getPageId() ] )
->assertResultSet( $expected );
}
public static function provideMagicWords() {
yield 'PAGEID' => [
'Test {{PAGEID}} Test',
static function ( RevisionRecord $rev ) {
return $rev->getPageId();
}
];
yield 'REVISIONID' => [
'Test {{REVISIONID}} Test',
static function ( RevisionRecord $rev ) {
return $rev->getId();
}
];
yield 'REVISIONUSER' => [
'Test {{REVISIONUSER}} Test',
static function ( RevisionRecord $rev ) {
return $rev->getUser()->getName();
}
];
yield 'REVISIONTIMESTAMP' => [
'Test {{REVISIONTIMESTAMP}} Test',
static function ( RevisionRecord $rev ) {
return $rev->getTimestamp();
}
];
yield 'subst:REVISIONUSER' => [
'Test {{subst:REVISIONUSER}} Test',
static function ( RevisionRecord $rev ) {
return $rev->getUser()->getName();
},
'subst'
];
yield 'subst:PAGENAME' => [
'Test {{subst:PAGENAME}} Test',
static function ( RevisionRecord $rev ) {
return 'PageUpdaterTest::testMagicWords';
},
'subst'
];
}
/**
* @covers \MediaWiki\Storage\PageUpdater::saveRevision()
*
* Integration test for PageUpdater, DerivedPageDataUpdater, RevisionRenderer
* and RenderedRevision, that ensures that magic words depending on revision meta-data
* are handled correctly. Note that each magic word needs to be tested separately,
* to assert correct behavior for each "vary" flag in the ParserOutput.
*
* @dataProvider provideMagicWords
*/
public function testMagicWords( $wikitext, $callback, $subst = false ) {
$user = User::newFromName( 'A user for ' . __METHOD__ );
$user->addToDatabase();
$title = $this->getDummyTitle( __METHOD__ . '-' . $this->getName() );
$this->insertPage( $title );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$updater = $page->newPageUpdater( $user )
->setContent( SlotRecord::MAIN, new \MediaWiki\Content\WikitextContent( $wikitext ) );
$summary = CommentStoreComment::newUnsavedComment( 'Just a test' );
$rev = $updater->saveRevision( $summary, EDIT_UPDATE );
if ( !$rev ) {
$this->fail( $updater->getStatus()->getWikiText() );
}
$expected = strval( $callback( $rev ) );
$output = $page->getParserOutput( ParserOptions::newFromAnon() );
$html = $output->getRawText();
$text = $rev->getContent( SlotRecord::MAIN )->serialize();
if ( $subst ) {
$this->assertStringContainsString( $expected, $text, 'In Wikitext' );
}
$this->assertStringContainsString( $expected, $html, 'In HTML' );
}
public function testChangeTagsSuppressRecentChange() {
$page = PageIdentityValue::localIdentity( 0, NS_MAIN, __METHOD__ );
$wikiPageFactory = $this->getServiceContainer()->getWikiPageFactory();
$revision = $this->getServiceContainer()
->getPageUpdaterFactory()
->newPageUpdater(
$wikiPageFactory->newFromTitle( $page ),
$this->getTestUser()->getUser()
)
->setContent( SlotRecord::MAIN, new TextContent( 'Lorem Ipsum' ) )
->addTag( 'foo' )
->setFlags( EDIT_SUPPRESS_RC )
->saveRevision( CommentStoreComment::newUnsavedComment( 'Comment' ) );
$this->assertArrayEquals(
[ 'foo' ],
$this->getServiceContainer()->getChangeTagsStore()->getTags(
$this->getDb(), null, $revision->getId()
)
);
$revision2 = $this->getServiceContainer()
->getPageUpdaterFactory()
->newPageUpdater(
$wikiPageFactory->newFromTitle( $page ),
$this->getTestUser()->getUser()
)
->setContent( SlotRecord::MAIN, new TextContent( 'Other content' ) )
->addTag( 'bar' )
->setFlags( EDIT_SUPPRESS_RC )
->saveRevision( CommentStoreComment::newUnsavedComment( 'Comment' ) );
$this->assertArrayEquals(
[ 'bar' ],
$this->getServiceContainer()->getChangeTagsStore()->getTags(
$this->getDb(), null, $revision2->getId()
)
);
}
/**
* @covers \MediaWiki\Storage\PageUpdater::prepareUpdate()
* @covers \WikiPage::getCurrentUpdate()
*/
public function testPrepareUpdate() {
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$updater = $page->newPageUpdater( $user );
$this->assertSame( $page->getCurrentUpdate(), $updater->prepareUpdate() );
}
/**
* @covers \MediaWiki\Storage\PageUpdater::preventChange
* @covers \MediaWiki\Storage\PageUpdater::doModify
* @covers \MediaWiki\Storage\PageUpdater::isChange
*/
public function testPreventChange_modify() {
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$updater = $page->newPageUpdater( $user );
// Creation
$summary = CommentStoreComment::newUnsavedComment( 'one' );
$updater->setContent( SlotRecord::MAIN, new TextContent( 'Lorem ipsum' ) );
$updater->prepareUpdate();
$rev = $updater->saveRevision( $summary, EDIT_NEW );
$this->assertInstanceOf( RevisionRecord::class, $rev );
// Null edit
$updater = $page->newPageUpdater( $user );
$summary = CommentStoreComment::newUnsavedComment( 'one' );
$updater->setContent( SlotRecord::MAIN, new TextContent( 'Lorem ipsum' ) );
$updater->prepareUpdate();
$updater->preventChange();
$this->assertFalse( $updater->isChange() );
$rev = $updater->saveRevision( $summary );
$this->assertNull( $rev );
// Prevented edit
$updater = $page->newPageUpdater( $user );
$summary = CommentStoreComment::newUnsavedComment( 'one' );
$updater->setContent( SlotRecord::MAIN, new TextContent( 'dolor sit amet' ) );
$updater->prepareUpdate();
$updater->preventChange();
$this->expectException( LogicException::class );
$updater->saveRevision( $summary );
}
/**
* @covers \MediaWiki\Storage\PageUpdater::preventChange
* @covers \MediaWiki\Storage\PageUpdater::doCreate
* @covers \MediaWiki\Storage\PageUpdater::isChange
*/
public function testPreventChange_create() {
$user = $this->getTestUser()->getUser();
$title = $this->getDummyTitle( __METHOD__ );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$updater = $page->newPageUpdater( $user );
$summary = CommentStoreComment::newUnsavedComment( 'one' );
$updater->setContent( SlotRecord::MAIN, new TextContent( 'Lorem ipsum' ) );
$updater->prepareUpdate();
$updater->preventChange();
$this->assertTrue( $updater->isChange() );
$this->expectException( LogicException::class );
$updater->saveRevision( $summary, EDIT_NEW );
}
public function testUpdateAuthor() {
$title = $this->getDummyTitle( __METHOD__ );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$user = new User;
$user->setName( 'PageUpdaterTest' );
$updater = $page->newPageUpdater( $user );
$summary = CommentStoreComment::newUnsavedComment( 'one' );
$updater->setContent( SlotRecord::MAIN, new TextContent( '~~~~' ) );
$user = User::createNew( $user->getName() );
$updater->updateAuthor( $user );
$rev = $updater->saveRevision( $summary, EDIT_NEW );
$this->assertGreaterThan( 0, $rev->getUser()->getId() );
}
}
PK !
N N Storage/SqlBlobStoreTest.phpnu Iw getServiceContainer();
$store = new SqlBlobStore(
$services->getDBLoadBalancer(),
$extStore ?: $services->getExternalStoreAccess(),
$cache ?: $services->getMainWANObjectCache()
);
return $store;
}
public function testGetSetCompressRevisions() {
$store = $this->getBlobStore();
$this->assertFalse( $store->getCompressBlobs() );
$store->setCompressBlobs( true );
$this->assertTrue( $store->getCompressBlobs() );
}
public function testGetSetLegacyEncoding() {
$store = $this->getBlobStore();
$this->assertFalse( $store->getLegacyEncoding() );
$store->setLegacyEncoding( 'foo' );
$this->assertSame( 'foo', $store->getLegacyEncoding() );
}
public function testGetSetCacheExpiry() {
$store = $this->getBlobStore();
$this->assertSame( 604800, $store->getCacheExpiry() );
$store->setCacheExpiry( 12 );
$this->assertSame( 12, $store->getCacheExpiry() );
}
public function testGetSetUseExternalStore() {
$store = $this->getBlobStore();
$this->assertFalse( $store->getUseExternalStore() );
$store->setUseExternalStore( true );
$this->assertTrue( $store->getUseExternalStore() );
}
private function makeObjectBlob( $text ) {
$obj = new ConcatenatedGzipHistoryBlob();
$obj->setText( $text );
return serialize( $obj );
}
public function provideDecompress() {
yield '(no legacy encoding), empty in empty out' => [ false, '', [], '' ];
yield '(no legacy encoding), string in string out' => [ false, 'A', [], 'A' ];
yield '(no legacy encoding), error flag -> false' => [ false, 'X', [ 'error' ], false ];
yield '(no legacy encoding), string in with gzip flag returns string' => [
// gzip string below generated with gzdeflate( 'AAAABBAAA' )
false, "sttttr\002\022\000", [ 'gzip' ], 'AAAABBAAA',
];
yield '(no legacy encoding), string in with object flag returns false' => [
// gzip string below generated with serialize( 'JOJO' )
false, "s:4:\"JOJO\";", [ 'object' ], false,
];
yield '(no legacy encoding), serialized object in with object flag returns string' => [
false,
$this->makeObjectBlob( 'HHJJDDFF' ),
[ 'object' ],
'HHJJDDFF',
];
yield '(no legacy encoding), serialized object in with object & gzip flag returns string' => [
false,
gzdeflate( $this->makeObjectBlob( '8219JJJ840' ) ),
[ 'object', 'gzip' ],
'8219JJJ840',
];
yield '(ISO-8859-1 encoding), string in string out' => [
'ISO-8859-1',
iconv( 'utf-8', 'ISO-8859-1', "1®Àþ1" ),
[],
'1®Àþ1',
];
yield '(ISO-8859-1 encoding), serialized object in with gzip flags returns string' => [
'ISO-8859-1',
gzdeflate( iconv( 'utf-8', 'ISO-8859-1', "4®Àþ4" ) ),
[ 'gzip' ],
'4®Àþ4',
];
yield '(ISO-8859-1 encoding), serialized object in with object flags returns string' => [
'ISO-8859-1',
$this->makeObjectBlob( iconv( 'utf-8', 'ISO-8859-1', "3®Àþ3" ) ),
[ 'object' ],
'3®Àþ3',
];
yield '(ISO-8859-1 encoding), serialized object in with object & gzip flags returns string' => [
'ISO-8859-1',
gzdeflate( $this->makeObjectBlob( iconv( 'utf-8', 'ISO-8859-1', "2®Àþ2" ) ) ),
[ 'gzip', 'object' ],
'2®Àþ2',
];
yield 'T184749 (windows-1252 encoding), string in string out' => [
'windows-1252',
iconv( 'utf-8', 'windows-1252', "sammansättningar" ),
[],
'sammansättningar',
];
yield 'T184749 (windows-1252 encoding), string in string out with gzip' => [
'windows-1252',
gzdeflate( iconv( 'utf-8', 'windows-1252', "sammansättningar" ) ),
[ 'gzip' ],
'sammansättningar',
];
}
/**
* @dataProvider provideDecompress
* @param string|bool $legacyEncoding
* @param mixed $data
* @param array $flags
* @param mixed $expected
*/
public function testDecompressData( $legacyEncoding, $data, $flags, $expected ) {
$store = $this->getBlobStore();
if ( $legacyEncoding ) {
$store->setLegacyEncoding( $legacyEncoding );
}
$this->assertSame(
$expected,
$store->decompressData( $data, $flags )
);
}
public function testCompressRevisionTextUtf8() {
$store = $this->getBlobStore();
$row = (object)[ 'old_text' => "Wiki est l'\xc3\xa9cole superieur !" ];
$row->old_flags = $store->compressData( $row->old_text );
$this->assertStringContainsString( 'utf-8', $row->old_flags,
"Flags should contain 'utf-8'" );
$this->assertStringNotContainsString( 'gzip', $row->old_flags,
"Flags should not contain 'gzip'" );
$this->assertEquals( "Wiki est l'\xc3\xa9cole superieur !",
$row->old_text, "Direct check" );
}
/**
* @requires extension zlib
*/
public function testCompressRevisionTextUtf8Gzip() {
$store = $this->getBlobStore();
$store->setCompressBlobs( true );
$row = (object)[ 'old_text' => "Wiki est l'\xc3\xa9cole superieur !" ];
$row->old_flags = $store->compressData( $row->old_text );
$this->assertStringContainsString( 'utf-8', $row->old_flags,
"Flags should contain 'utf-8'" );
$this->assertStringContainsString( 'gzip', $row->old_flags,
"Flags should contain 'gzip'" );
$this->assertEquals( "Wiki est l'\xc3\xa9cole superieur !",
gzinflate( $row->old_text ), "Direct check" );
}
public static function provideBlobs() {
yield [ '' ];
yield [ 'someText' ];
yield [ "söme\ntäxt" ];
}
public function testSimpleStoreGetBlobKnownBad() {
$store = $this->getBlobStore();
$this->expectException( BadBlobException::class );
$store->getBlob( 'bad:lost?bug=T12345' );
}
/**
* @param string $blob
* @dataProvider provideBlobs
*/
public function testSimpleStoreGetBlobSimpleRoundtrip( $blob ) {
$store = $this->getBlobStore();
$address = $store->storeBlob( $blob );
$this->assertSame( $blob, $store->getBlob( $address ) );
}
public function testSimpleStorageGetBlobBatchSimpleEmpty() {
$store = $this->getBlobStore();
$this->assertArrayEquals(
[],
$store->getBlobBatch( [] )->getValue()
);
}
/**
* @param string $blob
* @dataProvider provideBlobs
*/
public function testSimpleStorageGetBlobBatchSimpleRoundtrip( $blob ) {
$store = $this->getBlobStore();
$addresses = [
$store->storeBlob( $blob ),
$store->storeBlob( $blob . '1' )
];
$this->assertArrayEquals(
array_combine( $addresses, [ $blob, $blob . '1' ] ),
$store->getBlobBatch( $addresses )->getValue()
);
}
public function testCachingConsistency() {
$cache = new WANObjectCache( [ 'cache' => new HashBagOStuff() ] );
$store = $this->getBlobStore( $cache );
$addrA = $store->storeBlob( 'A' );
$addrB = $store->storeBlob( 'B' );
$addrC = $store->storeBlob( 'C' );
$addrD = $store->storeBlob( 'D' );
$addrX = 'tt:0';
$dataZ = "söme\ntäxt!";
$addrZ = $store->storeBlob( $dataZ );
$this->assertArrayEquals(
[ $addrA => 'A', $addrC => 'C', $addrX => null ],
$store->getBlobBatch( [ $addrA, $addrC, $addrX ] )->getValue(),
false, true
);
$this->assertEquals( 'A', $store->getBlob( $addrA ) );
$this->assertEquals( 'B', $store->getBlob( $addrB ) );
$this->assertEquals( 'C', $store->getBlob( $addrC ) );
$this->assertArrayEquals(
[ $addrB => 'B', $addrC => 'C', $addrD => 'D' ],
$store->getBlobBatch( [ $addrB, $addrC, $addrD ] )->getValue(),
false, true
);
$this->assertEquals( $dataZ, $store->getBlob( $addrZ ) );
$this->assertArrayEquals(
[ $addrA => 'A', $addrZ => $dataZ ],
$store->getBlobBatch( [ $addrA, $addrZ ] )->getValue(),
false, true
);
}
public function testSimpleStorageNonExistentBlob() {
$this->expectException( BlobAccessException::class );
$store = $this->getBlobStore();
$store->getBlob( 'tt:this_will_not_exist' );
}
public function testSimpleStorageNonExistentBlobBatch() {
$store = $this->getBlobStore();
$result = $store->getBlobBatch( [
'tt:this_will_not_exist',
'tt:0',
'tt:-1',
'tt:10000',
'bla:1001'
] );
$resultBlobs = $result->getValue();
$expected = [
'tt:this_will_not_exist' => null,
'tt:0' => null,
'tt:-1' => null,
'tt:10000' => null,
'bla:1001' => null
];
ksort( $expected );
ksort( $resultBlobs );
$this->assertSame( $expected, $resultBlobs );
$this->assertStatusMessagesExactly(
StatusValue::newGood()
->warning( 'internalerror', 'Bad blob address: tt:this_will_not_exist. Use findBadBlobs.php to remedy.' )
->warning( 'internalerror', 'Bad blob address: tt:0. Use findBadBlobs.php to remedy.' )
->warning( 'internalerror', 'Bad blob address: tt:-1. Use findBadBlobs.php to remedy.' )
->warning( 'internalerror', 'Unknown blob address schema: bla. Use findBadBlobs.php to remedy.' )
->warning( 'internalerror', 'Unable to fetch blob at tt:10000. Use findBadBlobs.php to remedy.' ),
$result
);
}
public function testSimpleStoragePartialNonExistentBlobBatch() {
$store = $this->getBlobStore();
$address = $store->storeBlob( 'test_data' );
$result = $store->getBlobBatch( [ $address, 'tt:this_will_not_exist_too' ] );
$resultBlobs = $result->getValue();
$expected = [
$address => 'test_data',
'tt:this_will_not_exist_too' => null
];
ksort( $expected );
ksort( $resultBlobs );
$this->assertSame( $expected, $resultBlobs );
$this->assertStatusMessagesExactly(
StatusValue::newGood()
->warning( 'internalerror', 'Bad blob address: tt:this_will_not_exist_too. Use findBadBlobs.php to remedy.' ),
$result
);
}
/**
* @dataProvider provideBlobs
*/
public function testSimpleStoreGetBlobSimpleRoundtripWindowsLegacyEncoding( $blob ) {
$store = $this->getBlobStore();
$store->setLegacyEncoding( 'windows-1252' );
$address = $store->storeBlob( $blob );
$this->assertSame( $blob, $store->getBlob( $address ) );
}
/**
* @dataProvider provideBlobs
*/
public function testSimpleStoreGetBlobSimpleRoundtripWindowsLegacyEncodingGzip( $blob ) {
// FIXME: fails under postgres - T298692
$this->markTestSkippedIfDbType( 'postgres' );
$store = $this->getBlobStore();
$store->setLegacyEncoding( 'windows-1252' );
$store->setCompressBlobs( true );
$address = $store->storeBlob( $blob );
$this->assertSame( $blob, $store->getBlob( $address ) );
}
public static function provideGetTextIdFromAddress() {
yield [ 'tt:17', 17 ];
yield [ 'xy:17', null ];
yield [ 'xy:xyzzy', null ];
}
/**
* @dataProvider provideGetTextIdFromAddress
*/
public function testGetTextIdFromAddress( $address, $textId ) {
$store = $this->getBlobStore();
$this->assertSame( $textId, $store->getTextIdFromAddress( $address ) );
}
public static function provideGetTextIdFromAddressInvalidArgumentException() {
yield [ 'tt:xy' ];
yield [ 'tt:0' ];
yield [ 'tt:' ];
yield [ 'xy' ];
yield [ '' ];
}
/**
* @dataProvider provideGetTextIdFromAddressInvalidArgumentException
*/
public function testGetTextIdFromAddressInvalidArgumentException( $address ) {
$this->expectException( InvalidArgumentException::class );
$store = $this->getBlobStore();
$store->getTextIdFromAddress( $address );
}
public function testMakeAddressFromTextId() {
$this->assertSame( 'tt:17', SqlBlobStore::makeAddressFromTextId( 17 ) );
}
public static function providerSplitBlobAddress() {
yield [ 'tt:123', 'tt', '123', [] ];
yield [ 'bad:foo?x=y', 'bad', 'foo', [ 'x' => 'y' ] ];
yield [ 'http://test.com/foo/bar?a=b', 'http', 'test.com/foo/bar', [ 'a' => 'b' ] ];
}
/**
* @dataProvider providerSplitBlobAddress
*/
public function testSplitBlobAddress( $address, $schema, $id, $parameters ) {
$this->assertSame( 'tt:17', SqlBlobStore::makeAddressFromTextId( 17 ) );
}
public static function provideExpandBlob() {
yield 'Generic test' => [
'This is a goat of revision text.',
'old_flags' => '',
'old_text' => 'This is a goat of revision text.',
];
}
/**
* @dataProvider provideExpandBlob
*/
public function testExpandBlob( $expected, $flags, $raw ) {
$blobStore = $this->getBlobStore();
$this->assertEquals(
$expected,
$blobStore->expandBlob( $raw, explode( ',', $flags ) )
);
}
public static function provideExpandBlobWithZlibExtension() {
yield 'Generic gzip test' => [
'This is a small goat of revision text.',
'old_flags' => 'gzip',
'old_text' => gzdeflate( 'This is a small goat of revision text.' ),
];
}
/**
* @dataProvider provideExpandBlobWithZlibExtension
* @requires extension zlib
*/
public function testGetRevisionWithZlibExtension( $expected, $flags, $raw ) {
$blobStore = $this->getBlobStore();
$this->assertEquals(
$expected,
$blobStore->expandBlob( $raw, explode( ',', $flags ) )
);
}
public static function provideExpandBlobWithZlibExtension_badData() {
yield 'Generic gzip test' => [
'old_flags' => 'gzip',
'old_text' => 'DEAD BEEF',
];
}
/**
* @dataProvider provideExpandBlobWithZlibExtension_badData
* @requires extension zlib
*/
public function testGetRevisionWithZlibExtension_badData( $flags, $raw ) {
$blobStore = $this->getBlobStore();
$this->assertFalse(
@$blobStore->expandBlob( $raw, explode( ',', $flags ) )
);
}
public static function provideExpandBlobWithLegacyEncoding() {
yield 'Utf8Native' => [
"Wiki est l'\xc3\xa9cole superieur !",
'iso-8859-1',
'old_flags' => 'utf-8',
'old_text' => "Wiki est l'\xc3\xa9cole superieur !",
];
yield 'Utf8Legacy' => [
"Wiki est l'\xc3\xa9cole superieur !",
'iso-8859-1',
'old_flags' => '',
'old_text' => "Wiki est l'\xe9cole superieur !",
];
}
/**
* @dataProvider provideExpandBlobWithLegacyEncoding
*/
public function testGetRevisionWithLegacyEncoding( $expected, $encoding, $flags, $raw ) {
$blobStore = $this->getBlobStore();
$blobStore->setLegacyEncoding( $encoding );
$this->assertEquals(
$expected,
$blobStore->expandBlob( $raw, explode( ',', $flags ) )
);
}
public static function provideExpandBlobWithGzipAndLegacyEncoding() {
/**
* WARNING!
* Do not set the external flag!
* Otherwise, getRevisionText will hit the live database (if ExternalStore is enabled)!
*/
yield 'Utf8NativeGzip' => [
"Wiki est l'\xc3\xa9cole superieur !",
'iso-8859-1',
'old_flags' => 'gzip,utf-8',
'old_text' => gzdeflate( "Wiki est l'\xc3\xa9cole superieur !" ),
];
yield 'Utf8LegacyGzip' => [
"Wiki est l'\xc3\xa9cole superieur !",
'iso-8859-1',
'old_flags' => 'gzip',
'old_text' => gzdeflate( "Wiki est l'\xe9cole superieur !" ),
];
}
/**
* @dataProvider provideExpandBlobWithGzipAndLegacyEncoding
* @requires extension zlib
*/
public function testGetRevisionWithGzipAndLegacyEncoding( $expected, $encoding, $flags, $raw ) {
$blobStore = $this->getBlobStore();
$blobStore->setLegacyEncoding( $encoding );
$this->assertEquals(
$expected,
$blobStore->expandBlob( $raw, explode( ',', $flags ) )
);
}
public static function provideTestGetRevisionText_returnsDecompressedTextFieldWhenNotExternal() {
yield 'Just text' => [
'old_flags' => '',
'old_text' => 'SomeText',
'SomeText'
];
// gzip string below generated with gzdeflate( 'AAAABBAAA' )
yield 'gzip text' => [
'old_flags' => 'gzip',
'old_text' => "sttttr\002\022\000",
'AAAABBAAA'
];
}
/**
* @dataProvider provideTestGetRevisionText_returnsDecompressedTextFieldWhenNotExternal
*/
public function testGetRevisionText_returnsDecompressedTextFieldWhenNotExternal(
$flags,
$raw,
$expected
) {
$blobStore = $this->getBlobStore();
$this->assertSame( $expected, $blobStore->expandBlob( $raw, $flags ) );
}
public static function provideTestGetRevisionText_external_returnsFalseWhenNotEnoughUrlParts() {
yield 'Just some text' => [ 'someNonUrlText' ];
yield 'No second URL part' => [ 'someProtocol://' ];
}
/**
* @dataProvider provideTestGetRevisionText_external_returnsFalseWhenNotEnoughUrlParts
*/
public function testGetRevisionText_external_returnsFalseWhenNotEnoughUrlParts(
$text
) {
$blobStore = $this->getBlobStore();
$this->assertFalse(
$blobStore->expandBlob(
$text,
[ 'external' ]
)
);
}
public function testGetRevisionText_external_noOldId() {
$this->setService(
'ExternalStoreFactory',
new ExternalStoreFactory( [ 'ForTesting' ], [ 'ForTesting://cluster1' ], 'test-id' )
);
$blobStore = $this->getBlobStore();
$this->assertSame(
'AAAABBAAA',
$blobStore->expandBlob(
'ForTesting://cluster1/12345',
[ 'external', 'gzip' ]
)
);
}
private function getWANObjectCache() {
return new WANObjectCache( [ 'cache' => new HashBagOStuff() ] );
}
public function testGetRevisionText_external_oldId() {
$cache = $this->getWANObjectCache();
$this->setService( 'MainWANObjectCache', $cache );
$this->setService(
'ExternalStoreFactory',
new ExternalStoreFactory( [ 'ForTesting' ], [ 'ForTesting://cluster1' ], 'test-id' )
);
$lb = $this->createMock( LoadBalancer::class );
$access = $this->getServiceContainer()->getExternalStoreAccess();
$blobStore = new SqlBlobStore( $lb, $access, $cache );
$this->assertSame(
'AAAABBAAA',
$blobStore->expandBlob(
'ForTesting://cluster1/12345',
'external,gzip',
'tt:7777'
)
);
$cacheKey = $cache->makeGlobalKey(
'SqlBlobStore-blob',
$lb->getLocalDomainID(),
'tt:7777'
);
$this->assertSame( 'AAAABBAAA', $cache->get( $cacheKey ) );
}
public function testGetRevisionText_external_oldId_direct_access() {
$cache = $this->getWANObjectCache();
$this->setService( 'MainWANObjectCache', $cache );
$this->setService(
'ExternalStoreFactory',
new ExternalStoreFactory( [ 'ForTesting' ], [ 'ForTesting://cluster1' ], 'test-id' )
);
$lb = $this->createMock( LoadBalancer::class );
$access = $this->getServiceContainer()->getExternalStoreAccess();
$blobStore = new SqlBlobStore( $lb, $access, $cache );
$this->assertSame(
'AAAABBAAA',
$blobStore->getBlob( 'es:ForTesting://cluster1/12345?flags=external,gzip' )
);
$cacheKey = $cache->makeGlobalKey(
'SqlBlobStore-blob',
$lb->getLocalDomainID(),
// See ExternalStoreForTesting for the path
'es:ForTesting://cluster1/12345?flags=external,gzip'
);
$this->assertSame( 'AAAABBAAA', $cache->get( $cacheKey ) );
}
public static function provideTestGetRevisionText_external_oldId_direct_store() {
yield 'no compression' => [ false ];
yield 'compression' => [ true ];
}
/**
* @dataProvider provideTestGetRevisionText_external_oldId_direct_store
*/
public function testGetRevisionText_external_oldId_direct_store( bool $compression ) {
$cache = $this->getWANObjectCache();
$this->setService( 'MainWANObjectCache', $cache );
$this->setService(
'ExternalStoreFactory',
new ExternalStoreFactory( [ 'ForTesting' ], [ 'ForTesting://cluster1' ], 'test-id' )
);
$lb = $this->createMock( LoadBalancer::class );
$access = $this->getServiceContainer()->getExternalStoreAccess();
$blobStore = new SqlBlobStore( $lb, $access, $cache );
$blobStore->setUseExternalStore( true );
$blobStore->setCompressBlobs( $compression );
$id = $blobStore->storeBlob( 'A very unique text' );
$this->assertStringStartsWith( 'es:ForTesting://cluster1/', $id );
$this->assertSame(
'A very unique text',
$blobStore->getBlob( $id )
);
$cacheKey = $cache->makeGlobalKey(
'SqlBlobStore-blob',
$lb->getLocalDomainID(),
$id
);
$this->assertSame( 'A very unique text', $cache->get( $cacheKey ) );
}
}
PK ! ڬG & Storage/DerivedPageDataUpdaterTest.phpnu Iw getDefaultWikitextNS(), $title );
}
/**
* @param string|Title $title
*
* @return WikiPage
*/
private function getPage( $title ) {
$title = ( $title instanceof Title ) ? $title : $this->getTitle( $title );
return $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
}
/**
* @param string|Title|WikiPage $page
* @param RevisionRecord|null $rec
* @param User|null $user
*
* @return DerivedPageDataUpdater
*/
private function getDerivedPageDataUpdater(
$page, ?RevisionRecord $rec = null, ?User $user = null
) {
if ( is_string( $page ) || $page instanceof Title ) {
$page = $this->getPage( $page );
}
$page = TestingAccessWrapper::newFromObject( $page );
return $page->getDerivedDataUpdater( $user, $rec );
}
/**
* Creates a revision in the database.
*
* @param WikiPage $page
* @param string|Message|CommentStoreComment $summary
* @param null|string|Content|Content[] $content
* @param User|null $user
*
* @return RevisionRecord|null
*/
private function createRevision( WikiPage $page, $summary, $content = null, $user = null ) {
$user ??= $this->getTestUser()->getUser();
$comment = CommentStoreComment::newUnsavedComment( $summary );
if ( $content === null || is_string( $content ) ) {
$content = new WikitextContent( $content ?? $summary );
}
if ( !is_array( $content ) ) {
$content = [ SlotRecord::MAIN => $content ];
}
$this->getDerivedPageDataUpdater( $page ); // flush cached instance before.
$updater = $page->newPageUpdater( $user );
foreach ( $content as $role => $c ) {
$updater->setContent( $role, $c );
}
$rev = $updater->saveRevision( $comment );
if ( !$updater->wasSuccessful() ) {
$this->fail( $updater->getStatus()->getWikiText() );
}
$this->getDerivedPageDataUpdater( $page ); // flush cached instance after.
return $rev;
}
// TODO: test setArticleCountMethod() and isCountable();
// TODO: test isRedirect() and wasRedirect()
/**
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getCanonicalParserOptions()
*/
public function testGetCanonicalParserOptions() {
$user = $this->getTestUser()->getUser();
$page = $this->getPage( __METHOD__ );
$parentRev = $this->createRevision( $page, 'first' );
$mainContent = new WikitextContent( 'Lorem ipsum' );
$update = new RevisionSlotsUpdate();
$update->modifyContent( SlotRecord::MAIN, $mainContent );
$updater = $this->getDerivedPageDataUpdater( $page );
$updater->prepareContent( $user, $update, false );
$options1 = $updater->getCanonicalParserOptions();
$this->assertSame( $this->getServiceContainer()->getContentLanguage(),
$options1->getUserLangObj() );
$speculativeId = $options1->getSpeculativeRevId();
$this->assertSame( $parentRev->getId() + 1, $speculativeId );
$rev = $this->makeRevision(
$page->getTitle(),
$update,
$user,
$parentRev->getId() + 7,
$parentRev->getId()
);
$updater->prepareUpdate( $rev );
$options2 = $updater->getCanonicalParserOptions();
$currentRev = $options2->getCurrentRevisionRecordCallback()( $page->getTitle() );
$this->assertSame( $rev->getId(), $currentRev->getId() );
}
/**
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::grabCurrentRevision()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::pageExisted()
*/
public function testGrabCurrentRevision() {
$page = $this->getPage( __METHOD__ );
$updater0 = $this->getDerivedPageDataUpdater( $page );
$this->assertNull( $updater0->grabCurrentRevision() );
$this->assertFalse( $updater0->pageExisted() );
$rev1 = $this->createRevision( $page, 'first' );
$updater1 = $this->getDerivedPageDataUpdater( $page );
$this->assertSame( $rev1->getId(), $updater1->grabCurrentRevision()->getId() );
$this->assertFalse( $updater0->pageExisted() );
$this->assertTrue( $updater1->pageExisted() );
$rev2 = $this->createRevision( $page, 'second' );
$updater2 = $this->getDerivedPageDataUpdater( $page );
$this->assertSame( $rev1->getId(), $updater1->grabCurrentRevision()->getId() );
$this->assertSame( $rev2->getId(), $updater2->grabCurrentRevision()->getId() );
}
/**
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::prepareContent()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::isContentPrepared()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::pageExisted()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::isCreation()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::isChange()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getSlots()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getRawSlot()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getRawContent()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getModifiedSlotRoles()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getTouchedSlotRoles()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getSlotParserOutput()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getCanonicalParserOutput()
*/
public function testPrepareContent() {
$slotRoleRegistry = $this->getServiceContainer()->getSlotRoleRegistry();
if ( !$slotRoleRegistry->isDefinedRole( 'aux' ) ) {
$slotRoleRegistry->defineRoleWithModel(
'aux',
CONTENT_MODEL_WIKITEXT
);
}
$sysop = $this->getTestUser( [ 'sysop' ] )->getUser();
$updater = $this->getDerivedPageDataUpdater( __METHOD__ );
$this->assertFalse( $updater->isContentPrepared() );
// TODO: test stash
// TODO: MCR: Test multiple slots. Test slot removal.
$mainContent = new WikitextContent( 'first [[main]] ~~~' );
$auxContent = new WikitextContent( 'inherited ~~~ content' );
$auxSlot = SlotRecord::newSaved(
10, 7, 'tt:7',
SlotRecord::newUnsaved( 'aux', $auxContent )
);
$update = new RevisionSlotsUpdate();
$update->modifyContent( SlotRecord::MAIN, $mainContent );
$update->modifySlot( SlotRecord::newInherited( $auxSlot ) );
// TODO: MCR: test removing slots!
$updater->prepareContent( $sysop, $update, false );
// second be ok to call again with the same params
$updater->prepareContent( $sysop, $update, false );
$this->assertNull( $updater->grabCurrentRevision() );
$this->assertTrue( $updater->isContentPrepared() );
$this->assertFalse( $updater->isUpdatePrepared() );
$this->assertFalse( $updater->pageExisted() );
$this->assertTrue( $updater->isCreation() );
$this->assertTrue( $updater->isChange() );
$this->assertFalse( $updater->isContentDeleted() );
$this->assertNotNull( $updater->getRevision() );
$this->assertNotNull( $updater->getRenderedRevision() );
$this->assertEquals( [ SlotRecord::MAIN, 'aux' ], $updater->getSlots()->getSlotRoles() );
$this->assertEquals( [ SlotRecord::MAIN ], array_keys( $updater->getSlots()->getOriginalSlots() ) );
$this->assertEquals( [ 'aux' ], array_keys( $updater->getSlots()->getInheritedSlots() ) );
$this->assertEquals( [ SlotRecord::MAIN, 'aux' ], $updater->getModifiedSlotRoles() );
$this->assertEquals( [ SlotRecord::MAIN, 'aux' ], $updater->getTouchedSlotRoles() );
$mainSlot = $updater->getRawSlot( SlotRecord::MAIN );
$this->assertInstanceOf( SlotRecord::class, $mainSlot );
$this->assertStringNotContainsString(
'~~~',
$mainSlot->getContent()->serialize(),
'PST should apply.'
);
$this->assertStringContainsString( $sysop->getName(), $mainSlot->getContent()->serialize() );
$auxSlot = $updater->getRawSlot( 'aux' );
$this->assertInstanceOf( SlotRecord::class, $auxSlot );
$this->assertStringContainsString(
'~~~',
$auxSlot->getContent()->serialize(),
'No PST should apply.'
);
$mainOutput = $updater->getSlotParserOutput( SlotRecord::MAIN );
$text = $mainOutput->getRawText();
$this->assertStringContainsString( 'first', $text );
$this->assertStringContainsString( 'assertNotEmpty( $mainOutput->getLinks() );
$canonicalOutput = $updater->getCanonicalParserOutput();
$text = $canonicalOutput->getRawText();
$this->assertStringContainsString( 'first', $text );
$this->assertStringContainsString( 'assertStringContainsString( 'inherited ', $text );
$this->assertNotEmpty( $canonicalOutput->getLinks() );
}
/**
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::prepareContent()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::pageExisted()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::isCreation()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::isChange()
*/
public function testPrepareContentInherit() {
$sysop = $this->getTestUser( [ 'sysop' ] )->getUser();
$page = $this->getPage( __METHOD__ );
$mainContent1 = new WikitextContent( 'first [[main]] ({{REVISIONUSER}}) #~~~#' );
$mainContent2 = new WikitextContent( 'second ({{subst:REVISIONUSER}}) #~~~#' );
$rev = $this->createRevision( $page, 'first', $mainContent1 );
$mainContent1 = $rev->getContent( SlotRecord::MAIN ); // get post-pst content
$userName = $rev->getUser()->getName();
$sysopName = $sysop->getName();
$update = new RevisionSlotsUpdate();
$update->modifyContent( SlotRecord::MAIN, $mainContent1 );
$updater1 = $this->getDerivedPageDataUpdater( $page );
$updater1->prepareContent( $sysop, $update, false );
$this->assertNotNull( $updater1->grabCurrentRevision() );
$this->assertTrue( $updater1->isContentPrepared() );
$this->assertTrue( $updater1->pageExisted() );
$this->assertFalse( $updater1->isCreation() );
$this->assertFalse( $updater1->isChange() );
$this->assertNotNull( $updater1->getRevision() );
$this->assertNotNull( $updater1->getRenderedRevision() );
// parser-output for null-edit uses the original author's name
$html = $updater1->getRenderedRevision()->getRevisionParserOutput()->getRawText();
$this->assertStringNotContainsString( $sysopName, $html, '{{REVISIONUSER}}' );
$this->assertStringNotContainsString( '{{REVISIONUSER}}', $html, '{{REVISIONUSER}}' );
$this->assertStringNotContainsString( '~~~', $html, 'signature ~~~' );
$this->assertStringContainsString( '(' . $userName . ')', $html, '{{REVISIONUSER}}' );
$this->assertStringContainsString( '>' . $userName . '<', $html, 'signature ~~~' );
// prepare forced dummy revision
$emptyUpdate = new RevisionSlotsUpdate();
$updater1 = $this->getDerivedPageDataUpdater( $page );
$updater1->setForceEmptyRevision( true );
$updater1->prepareContent( $sysop, $emptyUpdate, false );
// dummy revision inherits slots, but not revision ID
$mainSlot0 = $rev->getSlot( SlotRecord::MAIN );
$dummyRev = $updater1->getRevision();
$dummySlot = $dummyRev->getSlot( SlotRecord::MAIN );
$this->assertSame( $mainSlot0->getAddress(), $dummySlot->getAddress() );
$this->assertNull( $dummyRev->getId() );
$this->assertSame( $rev->getId(), $dummyRev->getParentId() );
// prepare non-null
$update = new RevisionSlotsUpdate();
$update->modifyContent( SlotRecord::MAIN, $mainContent2 );
$updater2 = $this->getDerivedPageDataUpdater( $page );
$updater2->prepareContent( $sysop, $update, false );
// non-null edit use the new user name in PST
$pstText = $updater2->getSlots()->getContent( SlotRecord::MAIN )->serialize();
$this->assertStringNotContainsString(
'{{subst:REVISIONUSER}}',
$pstText,
'{{subst:REVISIONUSER}}'
);
$this->assertStringNotContainsString( '~~~', $pstText, 'signature ~~~' );
$this->assertStringContainsString( '(' . $sysopName . ')', $pstText, '{{subst:REVISIONUSER}}' );
$this->assertStringContainsString( ':' . $sysopName . '|', $pstText, 'signature ~~~' );
$this->assertFalse( $updater2->isCreation() );
$this->assertTrue( $updater2->isChange() );
}
// TODO: test failure of prepareContent() when called again...
// - with different user
// - with different update
// - after calling prepareUpdate()
/**
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::prepareUpdate()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::isUpdatePrepared()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::isCreation()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getSlots()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getRawSlot()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getRawContent()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getModifiedSlotRoles()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getTouchedSlotRoles()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getSlotParserOutput()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getCanonicalParserOutput()
*/
public function testPrepareUpdate() {
$page = $this->getPage( __METHOD__ );
$mainContent1 = new WikitextContent( 'first [[main]] ~~~' );
$rev1 = $this->createRevision( $page, 'first', $mainContent1 );
$updater1 = $this->getDerivedPageDataUpdater( $page, $rev1 );
$options = []; // TODO: test *all* the options...
$updater1->prepareUpdate( $rev1, $options );
$this->assertTrue( $updater1->isUpdatePrepared() );
$this->assertTrue( $updater1->isContentPrepared() );
$this->assertTrue( $updater1->isCreation() );
$this->assertTrue( $updater1->isChange() );
$this->assertFalse( $updater1->isContentDeleted() );
$this->assertNotNull( $updater1->getRevision() );
$this->assertNotNull( $updater1->getRenderedRevision() );
$this->assertEquals( [ SlotRecord::MAIN ], $updater1->getSlots()->getSlotRoles() );
$this->assertEquals( [ SlotRecord::MAIN ], array_keys( $updater1->getSlots()->getOriginalSlots() ) );
$this->assertEquals( [], array_keys( $updater1->getSlots()->getInheritedSlots() ) );
$this->assertEquals( [ SlotRecord::MAIN ], $updater1->getModifiedSlotRoles() );
$this->assertEquals( [ SlotRecord::MAIN ], $updater1->getTouchedSlotRoles() );
// TODO: MCR: test multiple slots, test slot removal!
$this->assertInstanceOf( SlotRecord::class, $updater1->getRawSlot( SlotRecord::MAIN ) );
$this->assertStringNotContainsString(
'~~~~',
$updater1->getRawContent( SlotRecord::MAIN )->serialize()
);
$mainOutput = $updater1->getSlotParserOutput( SlotRecord::MAIN );
$mainText = $mainOutput->getRawText();
$this->assertStringContainsString( 'first', $mainText );
$this->assertStringContainsString( 'assertNotEmpty( $mainOutput->getLinks() );
$canonicalOutput = $updater1->getCanonicalParserOutput();
$canonicalText = $canonicalOutput->getRawText();
$this->assertStringContainsString( 'first', $canonicalText );
$this->assertStringContainsString( 'assertNotEmpty( $canonicalOutput->getLinks() );
$mainContent2 = new WikitextContent( 'second' );
$rev2 = $this->createRevision( $page, 'second', $mainContent2 );
$updater2 = $this->getDerivedPageDataUpdater( $page, $rev2 );
$options = []; // TODO: test *all* the options...
$updater2->prepareUpdate( $rev2, $options );
$this->assertFalse( $updater2->isCreation() );
$this->assertTrue( $updater2->isChange() );
$canonicalOutput = $updater2->getCanonicalParserOutput();
$this->assertStringContainsString( 'second', $canonicalOutput->getRawText() );
}
/**
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::prepareUpdate()
*/
public function testPrepareUpdateReusesParserOutput() {
$user = $this->getTestUser()->getUser();
$page = $this->getPage( __METHOD__ );
$mainContent1 = new WikitextContent( 'first [[main]] ~~~' );
$update = new RevisionSlotsUpdate();
$update->modifyContent( SlotRecord::MAIN, $mainContent1 );
$updater = $this->getDerivedPageDataUpdater( $page );
$updater->prepareContent( $user, $update, false );
$mainOutput = $updater->getSlotParserOutput( SlotRecord::MAIN );
$canonicalOutput = $updater->getCanonicalParserOutput();
$rev = $this->createRevision( $page, 'first', $mainContent1 );
$options = []; // TODO: test *all* the options...
$updater->prepareUpdate( $rev, $options );
$this->assertTrue( $updater->isUpdatePrepared() );
$this->assertTrue( $updater->isContentPrepared() );
$this->assertSame( $mainOutput, $updater->getSlotParserOutput( SlotRecord::MAIN ) );
$this->assertSame( $canonicalOutput, $updater->getCanonicalParserOutput() );
}
/**
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::prepareUpdate()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getSlotParserOutput()
*/
public function testPrepareUpdateOutputReset() {
$user = $this->getTestUser()->getUser();
$page = $this->getPage( __METHOD__ );
$mainContent1 = new WikitextContent( 'first --{{REVISIONID}}--' );
$update = new RevisionSlotsUpdate();
$update->modifyContent( SlotRecord::MAIN, $mainContent1 );
$updater = $this->getDerivedPageDataUpdater( $page );
$updater->prepareContent( $user, $update, false );
$mainOutput = $updater->getSlotParserOutput( SlotRecord::MAIN );
$canonicalOutput = $updater->getCanonicalParserOutput();
// prevent optimization on matching speculative ID
$mainOutput->setSpeculativeRevIdUsed( 0 );
$canonicalOutput->setSpeculativeRevIdUsed( 0 );
$rev = $this->createRevision( $page, 'first', $mainContent1 );
$options = []; // TODO: test *all* the options...
$updater->prepareUpdate( $rev, $options );
$this->assertTrue( $updater->isUpdatePrepared() );
$this->assertTrue( $updater->isContentPrepared() );
// ParserOutput objects should have been flushed.
$this->assertNotSame( $mainOutput, $updater->getSlotParserOutput( SlotRecord::MAIN ) );
$this->assertNotSame( $canonicalOutput, $updater->getCanonicalParserOutput() );
$html = $updater->getCanonicalParserOutput()->getRawText();
$this->assertStringContainsString( '--' . $rev->getId() . '--', $html );
// TODO: MCR: ensure that when the main slot uses {{REVISIONID}} but another slot is
// updated, the main slot is still re-rendered!
}
// TODO: test failure of prepareUpdate() when called again with a different revision
// TODO: test failure of prepareUpdate() on inconsistency with prepareContent.
/**
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getPreparedEdit()
*/
public function testGetPreparedEditAfterPrepareContent() {
$user = $this->getTestUser()->getUser();
$mainContent = new WikitextContent( 'first [[main]] ~~~' );
$update = new RevisionSlotsUpdate();
$update->modifyContent( SlotRecord::MAIN, $mainContent );
$updater = $this->getDerivedPageDataUpdater( __METHOD__ );
$updater->prepareContent( $user, $update, false );
$canonicalOutput = $updater->getCanonicalParserOutput();
$preparedEdit = $updater->getPreparedEdit();
$this->assertSame( $canonicalOutput->getCacheTime(), $preparedEdit->timestamp );
$this->assertSame( $canonicalOutput, $preparedEdit->output );
$this->assertSame( $mainContent, $preparedEdit->newContent );
$this->assertSame( $updater->getRawContent( SlotRecord::MAIN ), $preparedEdit->pstContent );
$this->assertSame( $updater->getCanonicalParserOptions(), $preparedEdit->popts );
$this->assertSame( null, $preparedEdit->revid );
}
/**
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::getPreparedEdit()
*/
public function testGetPreparedEditAfterPrepareUpdate() {
$clock = MWTimestamp::convert( TS_UNIX, '20100101000000' );
MWTimestamp::setFakeTime( static function () use ( &$clock ) {
return $clock++;
} );
$page = $this->getPage( __METHOD__ );
$mainContent = new WikitextContent( 'first [[main]] ~~~' );
$update = new MutableRevisionSlots();
$update->setContent( SlotRecord::MAIN, $mainContent );
$rev = $this->createRevision( $page, __METHOD__ );
$updater = $this->getDerivedPageDataUpdater( $page );
$updater->prepareUpdate( $rev );
$canonicalOutput = $updater->getCanonicalParserOutput();
$preparedEdit = $updater->getPreparedEdit();
$this->assertSame( $canonicalOutput->getCacheTime(), $preparedEdit->timestamp );
$this->assertSame( $canonicalOutput, $preparedEdit->output );
$this->assertSame( $updater->getRawContent( SlotRecord::MAIN ), $preparedEdit->pstContent );
$this->assertSame( $updater->getCanonicalParserOptions(), $preparedEdit->popts );
$this->assertSame( $rev->getId(), $preparedEdit->revid );
}
public function testGetSecondaryDataUpdatesAfterPrepareContent() {
$user = $this->getTestUser()->getUser();
$page = $this->getPage( __METHOD__ );
$this->createRevision( $page, __METHOD__ );
$mainContent1 = new WikitextContent( 'first' );
$update = new RevisionSlotsUpdate();
$update->modifyContent( SlotRecord::MAIN, $mainContent1 );
$updater = $this->getDerivedPageDataUpdater( $page );
$updater->prepareContent( $user, $update, false );
$dataUpdates = $updater->getSecondaryDataUpdates();
$this->assertNotEmpty( $dataUpdates );
$linksUpdates = array_filter( $dataUpdates, static function ( $du ) {
return $du instanceof LinksUpdate;
} );
$this->assertCount( 1, $linksUpdates );
}
public function testAvoidSecondaryDataUpdatesOnNonHTMLContentHandlers() {
$this->overrideConfigValue(
MainConfigNames::ContentHandlers,
[
CONTENT_MODEL_WIKITEXT => [
'class' => WikitextContentHandler::class,
'services' => [
'TitleFactory',
'ParserFactory',
'GlobalIdGenerator',
'LanguageNameUtils',
'LinkRenderer',
'MagicWordFactory',
'ParsoidParserFactory',
],
],
'testing' => DummyContentHandlerForTesting::class,
]
);
$user = $this->getTestUser()->getUser();
$page = $this->getPage( __METHOD__ );
$this->createRevision( $page, __METHOD__ );
$contentHandler = new DummyContentHandlerForTesting( 'testing' );
$mainContent1 = $contentHandler->unserializeContent( serialize( 'first' ) );
$update = new RevisionSlotsUpdate();
$pcache = $this->getServiceContainer()->getParserCache();
$pcache->deleteOptionsKey( $page );
$rev = $this->createRevision( $page, 'first', $mainContent1 );
// Run updates
$update->modifyContent( SlotRecord::MAIN, $mainContent1 );
$updater = $this->getDerivedPageDataUpdater( $page );
$updater->prepareContent( $user, $update, false );
$dataUpdates = $updater->getSecondaryDataUpdates();
$updater->prepareUpdate( $rev );
$updater->doUpdates();
// Links updates should be triggered
$this->assertNotEmpty( $dataUpdates );
$linksUpdates = array_filter( $dataUpdates, static function ( $du ) {
return $du instanceof LinksUpdate;
} );
$this->assertCount( 1, $linksUpdates );
// Parser cache should not be populated.
$cached = $pcache->get( $page, $updater->getCanonicalParserOptions() );
$this->assertFalse( $cached );
}
public function testGetSecondaryDataUpdatesDeleted() {
$user = $this->getTestUser()->getUser();
$page = $this->getPage( __METHOD__ );
$this->createRevision( $page, __METHOD__ );
$mainContent1 = new WikitextContent( 'first' );
$update = new RevisionSlotsUpdate();
$update->modifyContent( SlotRecord::MAIN, $mainContent1 );
$updater = $this->getDerivedPageDataUpdater( $page );
$updater->prepareContent( $user, $update, false );
// Test that nothing happens if the page was deleted in the meantime
// This can happen when started by the job queue
$this->deletePage( $page );
$dataUpdates = $updater->getSecondaryDataUpdates();
$this->assertSame( [], $dataUpdates );
}
/**
* @param string $name
*
* @return ContentHandler
*/
private function defineMockContentModelForUpdateTesting( $name ) {
/** @var ContentHandler|MockObject $handler */
$handler = $this->getMockBuilder( TextContentHandler::class )
->setConstructorArgs( [ $name ] )
->onlyMethods(
[ 'getSecondaryDataUpdates', 'getDeletionUpdates', 'unserializeContent' ]
)
->getMock();
$dataUpdate = new MWCallableUpdate( 'time', "$name data update" );
$deletionUpdate = new MWCallableUpdate( 'time', "$name deletion update" );
$handler->method( 'getSecondaryDataUpdates' )->willReturn( [ $dataUpdate ] );
$handler->method( 'getDeletionUpdates' )->willReturn( [ $deletionUpdate ] );
$handler->method( 'unserializeContent' )->willReturnCallback(
function ( $text ) use ( $handler ) {
return $this->createMockContent( $handler, $text );
}
);
$this->mergeMwGlobalArrayValue(
'wgContentHandlers', [
$name => static function () use ( $handler ){
return $handler;
}
]
);
return $handler;
}
/**
* @param ContentHandler $handler
* @param string $text
*
* @return Content
*/
private function createMockContent( ContentHandler $handler, $text ) {
/** @var Content|MockObject $content */
$content = $this->getMockBuilder( TextContent::class )
->setConstructorArgs( [ $text ] )
->onlyMethods( [ 'getModel', 'getContentHandler' ] )
->getMock();
$content->method( 'getModel' )->willReturn( $handler->getModelID() );
$content->method( 'getContentHandler' )->willReturn( $handler );
return $content;
}
public function testGetSecondaryDataUpdatesWithSlotRemoval() {
$m1 = $this->defineMockContentModelForUpdateTesting( 'M1' );
$a1 = $this->defineMockContentModelForUpdateTesting( 'A1' );
$m2 = $this->defineMockContentModelForUpdateTesting( 'M2' );
$role = 'dpdu-test-a1';
$slotRoleRegistry = $this->getServiceContainer()->getSlotRoleRegistry();
$slotRoleRegistry->defineRoleWithModel(
$role,
$a1->getModelID()
);
// pin the service instance for this test
$this->setService( 'SlotRoleRegistry', $slotRoleRegistry );
$mainContent1 = $this->createMockContent( $m1, 'main 1' );
$auxContent1 = $this->createMockContent( $a1, 'aux 1' );
$mainContent2 = $this->createMockContent( $m2, 'main 2' );
$user = $this->getTestUser()->getUser();
$page = $this->getPage( __METHOD__ );
$this->createRevision(
$page,
__METHOD__,
[ SlotRecord::MAIN => $mainContent1, $role => $auxContent1 ]
);
$update = new RevisionSlotsUpdate();
$update->modifyContent( SlotRecord::MAIN, $mainContent2 );
$update->removeSlot( $role );
$page = $this->getPage( __METHOD__ );
$updater = $this->getDerivedPageDataUpdater( $page );
$updater->prepareContent( $user, $update, false );
$dataUpdates = $updater->getSecondaryDataUpdates();
$this->assertNotEmpty( $dataUpdates );
$updateNames = array_map( static function ( $du ) {
return $du instanceof MWCallableUpdate ? $du->getOrigin() : get_class( $du );
}, $dataUpdates );
$this->assertContains( LinksUpdate::class, $updateNames );
$this->assertContains( 'A1 deletion update', $updateNames );
$this->assertContains( 'M2 data update', $updateNames );
$this->assertNotContains( 'M1 data update', $updateNames );
}
/**
* Creates a dummy MutableRevisionRecord without touching the database.
*
* @param PageIdentity $title
* @param string|Content|Content[]|RevisionSlotsUpdate $update
* @param UserIdentity|null $user
* @param string $comment
* @param int $id
* @param int $parentId
*
* @return MutableRevisionRecord
*/
private function makeRevision(
PageIdentity $title,
$update,
?UserIdentity $user = null,
$comment = "testing",
$id = 0,
$parentId = 0
) {
$rev = new MutableRevisionRecord( $title );
if ( $update instanceof RevisionSlotsUpdate ) {
$rev->applyUpdate( $update );
} else {
if ( is_string( $update ) ) {
$update = new WikitextContent( $update );
}
if ( !is_array( $update ) ) {
$update = [ SlotRecord::MAIN => $update ];
}
foreach ( $update as $role => $content ) {
$rev->setContent( $role, $content );
}
}
if ( !$user ) {
$user = $this->getTestUser()->getUser();
}
$rev->setUser( $user );
$rev->setComment( CommentStoreComment::newUnsavedComment( $comment ) );
$rev->setPageId( $title->getId() );
$rev->setParentId( $parentId );
if ( $id ) {
$rev->setId( $id );
}
return $rev;
}
public function provideIsReusableFor() {
$title = PageIdentityValue::localIdentity( 1234, NS_MAIN, __CLASS__ );
$user1 = new UserIdentityValue( 111, 'Alice' );
$user2 = new UserIdentityValue( 222, 'Bob' );
$content1 = new WikitextContent( 'one' );
$content2 = new WikitextContent( 'two' );
$update1 = new RevisionSlotsUpdate();
$update1->modifyContent( SlotRecord::MAIN, $content1 );
$update1b = new RevisionSlotsUpdate();
$update1b->modifyContent( 'xyz', $content1 );
$update2 = new RevisionSlotsUpdate();
$update2->modifyContent( SlotRecord::MAIN, $content2 );
$rev1 = $this->makeRevision( $title, $update1, $user1, 'rev1', 11 );
$rev1b = $this->makeRevision( $title, $update1b, $user1, 'rev1', 11 );
$rev2 = $this->makeRevision( $title, $update2, $user1, 'rev2', 12 );
$rev2x = $this->makeRevision( $title, $update2, $user2, 'rev2', 12 );
$rev2y = $this->makeRevision( $title, $update2, $user1, 'rev2', 122 );
yield 'any' => [
'$prepUser' => null,
'$prepRevision' => null,
'$prepUpdate' => null,
'$forUser' => null,
'$forRevision' => null,
'$forUpdate' => null,
'$forParent' => null,
'$isReusable' => true,
];
yield 'for any' => [
'$prepUser' => $user1,
'$prepRevision' => $rev1,
'$prepUpdate' => $update1,
'$forUser' => null,
'$forRevision' => null,
'$forUpdate' => null,
'$forParent' => null,
'$isReusable' => true,
];
yield 'unprepared' => [
'$prepUser' => null,
'$prepRevision' => null,
'$prepUpdate' => null,
'$forUser' => $user1,
'$forRevision' => $rev1,
'$forUpdate' => $update1,
'$forParent' => 0,
'$isReusable' => true,
];
yield 'match prepareContent' => [
'$prepUser' => $user1,
'$prepRevision' => null,
'$prepUpdate' => $update1,
'$forUser' => $user1,
'$forRevision' => null,
'$forUpdate' => $update1,
'$forParent' => 0,
'$isReusable' => true,
];
yield 'match prepareUpdate' => [
'$prepUser' => null,
'$prepRevision' => $rev1,
'$prepUpdate' => null,
'$forUser' => $user1,
'$forRevision' => $rev1,
'$forUpdate' => null,
'$forParent' => 0,
'$isReusable' => true,
];
yield 'match all' => [
'$prepUser' => $user1,
'$prepRevision' => $rev1,
'$prepUpdate' => $update1,
'$forUser' => $user1,
'$forRevision' => $rev1,
'$forUpdate' => $update1,
'$forParent' => 0,
'$isReusable' => true,
];
yield 'mismatch prepareContent update' => [
'$prepUser' => $user1,
'$prepRevision' => null,
'$prepUpdate' => $update1,
'$forUser' => $user1,
'$forRevision' => null,
'$forUpdate' => $update1b,
'$forParent' => 0,
'$isReusable' => false,
];
yield 'mismatch prepareContent user' => [
'$prepUser' => $user1,
'$prepRevision' => null,
'$prepUpdate' => $update1,
'$forUser' => $user2,
'$forRevision' => null,
'$forUpdate' => $update1,
'$forParent' => 0,
'$isReusable' => false,
];
yield 'mismatch prepareContent parent' => [
'$prepUser' => $user1,
'$prepRevision' => null,
'$prepUpdate' => $update1,
'$forUser' => $user1,
'$forRevision' => null,
'$forUpdate' => $update1,
'$forParent' => 7,
'$isReusable' => false,
];
yield 'mismatch prepareUpdate revision update' => [
'$prepUser' => null,
'$prepRevision' => $rev1,
'$prepUpdate' => null,
'$forUser' => null,
'$forRevision' => $rev1b,
'$forUpdate' => null,
'$forParent' => 0,
'$isReusable' => false,
];
yield 'mismatch prepareUpdate revision id' => [
'$prepUser' => null,
'$prepRevision' => $rev2,
'$prepUpdate' => null,
'$forUser' => null,
'$forRevision' => $rev2y,
'$forUpdate' => null,
'$forParent' => 0,
'$isReusable' => false,
];
}
/**
* @dataProvider provideIsReusableFor
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::isReusableFor()
*/
public function testIsReusableFor(
?UserIdentity $prepUser,
?RevisionRecord $prepRevision,
?RevisionSlotsUpdate $prepUpdate,
?UserIdentity $forUser,
?RevisionRecord $forRevision,
?RevisionSlotsUpdate $forUpdate,
$forParent,
$isReusable
) {
$updater = $this->getDerivedPageDataUpdater( __METHOD__ );
if ( $prepUpdate ) {
$updater->prepareContent( $prepUser, $prepUpdate, false );
}
if ( $prepRevision ) {
$updater->prepareUpdate( $prepRevision );
}
$this->assertSame(
$isReusable,
$updater->isReusableFor( $forUser, $forRevision, $forUpdate, $forParent )
);
}
/**
* * @covers \MediaWiki\Storage\DerivedPageDataUpdater::isCountable
*/
public function testIsCountableNotContentPage() {
$updater = $this->getDerivedPageDataUpdater(
Title::makeTitle( NS_TALK, 'Main_Page' )
);
self::assertFalse( $updater->isCountable() );
}
public static function provideIsCountable() {
yield 'deleted revision' => [
'$articleCountMethod' => 'any',
'$wikitextContent' => 'Test',
'$revisionVisibility' => RevisionRecord::SUPPRESSED_ALL,
'$isCountable' => false
];
yield 'redirect' => [
'$articleCountMethod' => 'any',
'$wikitextContent' => '#REDIRECT [[Main_Page]]',
'$revisionVisibility' => 0,
'$isCountable' => false
];
yield 'no links count method any' => [
'$articleCountMethod' => 'any',
'$wikitextContent' => 'Test',
'$revisionVisibility' => 0,
'$isCountable' => true
];
yield 'no links count method link' => [
'$articleCountMethod' => 'link',
'$wikitextContent' => 'Test',
'$revisionVisibility' => 0,
'$isCountable' => false
];
yield 'with links count method link' => [
'$articleCountMethod' => 'link',
'$wikitextContent' => '[[Test]]',
'$revisionVisibility' => 0,
'$isCountable' => true
];
}
/**
* @dataProvider provideIsCountable
*
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::isCountable
*/
public function testIsCountable(
$articleCountMethod,
$wikitextContent,
$revisionVisibility,
$isCountable
) {
$this->overrideConfigValue( MainConfigNames::ArticleCountMethod, $articleCountMethod );
$title = $this->getTitle( 'Main_Page' );
$content = new WikitextContent( $wikitextContent );
$update = new RevisionSlotsUpdate();
$update->modifyContent( SlotRecord::MAIN, $content );
$revision = $this->makeRevision( $title, $update, User::newFromName( 'Alice' ), 'rev1', 13 );
$revision->setVisibility( $revisionVisibility );
$updater = $this->getDerivedPageDataUpdater( $title );
$updater->prepareUpdate( $revision );
self::assertSame( $isCountable, $updater->isCountable() );
}
/**
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::isCountable
*/
public function testIsCountableNoModifiedSlots() {
$page = $this->getPage( __METHOD__ );
$content = [ SlotRecord::MAIN => new WikitextContent( '[[Test]]' ) ];
$rev = $this->createRevision( $page, 'first', $content );
$nullRevision = MutableRevisionRecord::newFromParentRevision( $rev );
$nullRevision->setId( 14 );
$updater = $this->getDerivedPageDataUpdater( $page, $nullRevision );
$updater->prepareUpdate( $nullRevision );
$this->assertTrue( $updater->isCountable() );
}
/**
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::doUpdates()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::doSecondaryDataUpdates()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::doParserCacheUpdate()
*/
public function testDoUpdates() {
$page = $this->getPage( __METHOD__ );
$content = [ SlotRecord::MAIN => new WikitextContent( 'first [[main]]' ) ];
$content['aux'] = new WikitextContent( 'Aux [[Nix]]' );
$slotRoleRegistry = $this->getServiceContainer()->getSlotRoleRegistry();
if ( !$slotRoleRegistry->isDefinedRole( 'aux' ) ) {
$slotRoleRegistry->defineRoleWithModel(
'aux',
CONTENT_MODEL_WIKITEXT
);
}
$rev = $this->createRevision( $page, 'first', $content );
$pageId = $page->getId();
$oldStats = $this->getDb()->newSelectQueryBuilder()
->select( '*' )
->from( 'site_stats' )
->where( '1=1' )
->fetchRow();
$this->getDb()->newDeleteQueryBuilder()
->deleteFrom( 'pagelinks' )
->where( ISQLPlatform::ALL_ROWS )
->caller( __METHOD__ )
->execute();
$pcache = $this->getServiceContainer()->getParserCache();
$pcache->deleteOptionsKey( $page );
$updater = $this->getDerivedPageDataUpdater( $page, $rev );
$updater->setArticleCountMethod( 'link' );
$options = []; // TODO: test *all* the options...
$updater->prepareUpdate( $rev, $options );
$updater->doUpdates();
// links table update
$pageLinks = $this->getDb()->newSelectQueryBuilder()
->select( 'lt_title' )
->from( 'pagelinks' )
->join( 'linktarget', null, 'pl_target_id=lt_id' )
->where( [ 'pl_from' => $pageId ] )
->orderBy( [ 'lt_namespace', 'lt_title' ] )
->caller( __METHOD__ )->fetchResultSet();
$pageLinksRow = $pageLinks->fetchObject();
$this->assertIsObject( $pageLinksRow );
$this->assertSame( 'Main', $pageLinksRow->lt_title );
$pageLinksRow = $pageLinks->fetchObject();
$this->assertIsObject( $pageLinksRow );
$this->assertSame( 'Nix', $pageLinksRow->lt_title );
// parser cache update
$cached = $pcache->get( $page, $updater->getCanonicalParserOptions() );
$this->assertIsObject( $cached );
$expected = $updater->getCanonicalParserOutput();
$expected->clearParseStartTime();
$this->assertEquals( $expected, $cached );
// site stats
$stats = $this->getDb()->newSelectQueryBuilder()
->select( '*' )
->from( 'site_stats' )
->where( '1=1' )
->fetchRow();
$this->assertSame( $oldStats->ss_total_pages + 1, (int)$stats->ss_total_pages );
$this->assertSame( $oldStats->ss_total_edits + 1, (int)$stats->ss_total_edits );
$this->assertSame( $oldStats->ss_good_articles + 1, (int)$stats->ss_good_articles );
// TODO: MCR: test data updates for additional slots!
// TODO: test update for edit without page creation
// TODO: test message cache purge
// TODO: test module cache purge
// TODO: test CDN purge
// TODO: test newtalk update
// TODO: test search update
// TODO: test site stats good_articles while turning the page into (or back from) a redir.
// TODO: test category membership update (with setRcWatchCategoryMembership())
}
/**
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::doUpdates()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::doSecondaryDataUpdates()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::doParserCacheUpdate()
*/
public function testDoUpdatesCacheSaveDeferral_canonical() {
$page = $this->getPage( __METHOD__ );
// Case where user has canonical parser options
$content = [ SlotRecord::MAIN => new WikitextContent( 'rev ID ver #1: {{REVISIONID}}' ) ];
$rev = $this->createRevision( $page, 'first', $content );
$pcache = $this->getServiceContainer()->getParserCache();
$pcache->deleteOptionsKey( $page );
$this->getDb()->startAtomic( __METHOD__ ); // let deferred updates queue up
$updater = $this->getDerivedPageDataUpdater( $page, $rev );
$updater->prepareUpdate( $rev, [] );
$updater->doUpdates();
$this->assertGreaterThan( 0, DeferredUpdates::pendingUpdatesCount(), 'Pending updates' );
$this->assertNotFalse( $pcache->get( $page, $updater->getCanonicalParserOptions() ) );
$this->getDb()->endAtomic( __METHOD__ ); // run deferred updates
$this->assertSame( 0, DeferredUpdates::pendingUpdatesCount(), 'No pending updates' );
}
/**
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::doUpdates()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::doSecondaryDataUpdates()
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::doParserCacheUpdate()
*/
public function testDoUpdatesCacheSaveDeferral_noncanonical() {
$page = $this->getPage( __METHOD__ );
// Case where user does not have canonical parser options
$user = $this->getMutableTestUser()->getUser();
$services = $this->getServiceContainer();
$userOptionsManager = $services->getUserOptionsManager();
$userOptionsManager->setOption(
$user,
'thumbsize',
$userOptionsManager->getOption( $user, 'thumbsize' ) + 1
);
$content = [ SlotRecord::MAIN => new WikitextContent( 'rev ID ver #2: {{REVISIONID}}' ) ];
$rev = $this->createRevision( $page, 'first', $content, $user );
$pcache = $services->getParserCache();
$pcache->deleteOptionsKey( $page );
$this->getDb()->startAtomic( __METHOD__ ); // let deferred updates queue up
$updater = $this->getDerivedPageDataUpdater( $page, $rev, $user );
$updater->prepareUpdate( $rev, [] );
$updater->doUpdates();
$this->assertGreaterThan( 1, DeferredUpdates::pendingUpdatesCount(), 'Pending updates' );
$this->assertFalse( $pcache->get( $page, $updater->getCanonicalParserOptions() ) );
$this->getDb()->endAtomic( __METHOD__ ); // run deferred updates
$this->assertSame( 0, DeferredUpdates::pendingUpdatesCount(), 'No pending updates' );
$this->assertNotFalse( $pcache->get( $page, $updater->getCanonicalParserOptions() ) );
}
public static function provideEnqueueRevertedTagUpdateJob() {
return [
'approved' => [ true, 1 ],
'not approved' => [ false, 0 ]
];
}
/**
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::doUpdates
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::maybeEnqueueRevertedTagUpdateJob
* @dataProvider provideEnqueueRevertedTagUpdateJob
*/
public function testEnqueueRevertedTagUpdateJob( bool $approved, int $queueSize ) {
$page = $this->getPage( __METHOD__ );
$content = [ SlotRecord::MAIN => new WikitextContent( '1' ) ];
$rev = $this->createRevision( $page, '', $content );
$editResult = new EditResult(
false,
10,
EditResult::REVERT_ROLLBACK,
11,
12,
true,
false,
[ 'mw-rollback' ]
);
$updater = $this->getDerivedPageDataUpdater( $page, $rev );
$updater->prepareUpdate( $rev, [
'editResult' => $editResult,
'approved' => $approved
] );
$updater->doUpdates();
$services = $this->getServiceContainer();
$editResultCache = new EditResultCache(
$services->getMainObjectStash(),
$services->getConnectionProvider(),
new ServiceOptions(
EditResultCache::CONSTRUCTOR_OPTIONS,
[ MainConfigNames::RCMaxAge => BagOStuff::TTL_MONTH ]
)
);
if ( $approved ) {
$this->assertNull(
$editResultCache->get( $rev->getId() ),
'EditResult should not be cached when the revert is approved'
);
} else {
$this->assertEquals(
$editResult,
$editResultCache->get( $rev->getId() ),
'EditResult should be cached when the revert is not approved'
);
}
$jobQueueGroup = $this->getServiceContainer()->getJobQueueGroup();
$jobQueue = $jobQueueGroup->get( 'revertedTagUpdate' );
$this->assertSame(
$queueSize,
$jobQueue->getSize()
);
}
/**
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::doParserCacheUpdate()
* @covers \ParsoidCachePrewarmJob::doParsoidCacheUpdate()
*/
public function testDoParserCacheUpdate() {
$this->overrideConfigValue(
MainConfigNames::ParsoidCacheConfig,
[
'CacheThresholdTime' => 0.0,
'WarmParsoidParserCache' => true, // enable caching
]
);
$slotRoleRegistry = $this->getServiceContainer()->getSlotRoleRegistry();
if ( !$slotRoleRegistry->isDefinedRole( 'aux' ) ) {
$slotRoleRegistry->defineRoleWithModel(
'aux',
CONTENT_MODEL_WIKITEXT
);
}
// Create page
$page = $this->getPage( __METHOD__ );
ConvertibleTimestamp::setFakeTime( '2022-01-01T00:01:00Z' );
$this->createRevision( $page, 'Dummy' );
// Assert cache update after edit ----------
$parserCacheFactory = $this->getServiceContainer()->getParserCacheFactory();
$parserCache = $parserCacheFactory->getParserCache( ParserCacheFactory::DEFAULT_NAME );
$parsoidCache = $parserCacheFactory->getParserCache( "parsoid-" . ParserCacheFactory::DEFAULT_NAME );
$parserCache->deleteOptionsKey( $page );
$parsoidCache->deleteOptionsKey( $page );
$user = $this->getTestUser()->getUser();
ConvertibleTimestamp::setFakeTime( '2022-01-01T00:02:00Z' );
$updater = $page->newPageUpdater( $user );
$updater->setContent( SlotRecord::MAIN, new WikitextContent( 'first [[Main]]' ) );
$updater->setContent( 'aux', new WikitextContent( 'Aux [[Nix]]' ) );
$rev = $updater->saveRevision( CommentStoreComment::newUnsavedComment( 'testing' ) );
// run all the jobs
ConvertibleTimestamp::setFakeTime( '2022-01-01T00:03:00Z' );
$this->runJobs();
// Parsoid cache should have an entry
$parserOptions = ParserOptions::newFromAnon();
$parserOptions->setUseParsoid();
$parsoidCached = $parsoidCache->get( $page, $parserOptions, true );
$this->assertIsObject( $parsoidCached );
$this->assertStringContainsString( 'first', $parsoidCached->getRawText() );
// The parsoid parser output is generated during runJobs(), after the last call to setFakeTime().
$this->assertGreaterThan( $rev->getTimestamp(), $parsoidCached->getCacheTime() );
$this->assertSame( $rev->getId(), $parsoidCached->getCacheRevisionId() );
// Check that ParsoidRenderID::newFromParserOutput() doesn't throw,
// so we know that $parsoidCached is valid.
ParsoidRenderID::newFromParserOutput( $parsoidCached );
// The cached ParserOutput should not use the revision timestamp
// Create nwe ParserOptions object since we setUseParsoid() above
$parserOptions = ParserOptions::newFromAnon();
$cached = $parserCache->get( $page, $parserOptions, true );
$this->assertIsObject( $cached );
$this->assertNotSame( $parsoidCached, $cached );
$this->assertStringContainsString( 'first', $cached->getRawText() );
// The regular parser output is generated immediately during saveRevision(),
// so it uses the same timestamp as the revision.
$this->assertSame( $rev->getTimestamp(), $cached->getCacheTime() );
$this->assertSame( $rev->getId(), $cached->getCacheRevisionId() );
// Emulate forced update of an old revision ----------
ConvertibleTimestamp::setFakeTime( '2022-01-01T00:04:00Z' );
$parserCache->deleteOptionsKey( $page );
$updater = $this->getDerivedPageDataUpdater( $page );
$updater->prepareUpdate( $rev );
// Force the page timestamp, so we notice whether ParserOutput::getTimestamp
// or ParserOutput::getCacheTime are used.
$page->setTimestamp( $rev->getTimestamp() );
$updater->doParserCacheUpdate();
// The cached ParserOutput should not use the revision timestamp
$cached = $parserCache->get( $page, $updater->getCanonicalParserOptions(), true );
$this->assertIsObject( $cached );
$expected = $updater->getCanonicalParserOutput();
$expected->clearParseStartTime();
$this->assertEquals( $expected, $cached );
$this->assertGreaterThan( $rev->getTimestamp(), $cached->getCacheTime() );
$this->assertSame( $rev->getId(), $cached->getCacheRevisionId() );
}
/**
* @covers \MediaWiki\Storage\DerivedPageDataUpdater::doParserCacheUpdate()
* @covers \ParsoidCachePrewarmJob::doParsoidCacheUpdate()
*/
public function testDoParserCacheUpdateForJavaScriptContent() {
$this->overrideConfigValue(
MainConfigNames::ParsoidCacheConfig,
[
'CacheThresholdTime' => 0.0,
'WarmParsoidParserCache' => true, // enable caching
]
);
$page = $this->getPage( __METHOD__ );
$this->createRevision( $page, 'Dummy' );
$user = $this->getTestUser()->getUser();
$update = new RevisionSlotsUpdate();
$update->modifyContent( SlotRecord::MAIN, new JavaScriptContent( '{ first: "main"; }' ) );
// Emulate update after edit ----------
$parserCacheFactory = $this->getServiceContainer()->getParserCacheFactory();
$parserCache = $parserCacheFactory->getParserCache( ParserCacheFactory::DEFAULT_NAME );
$parsoidCache = $parserCacheFactory->getParserCache( ParserOutputAccess::PARSOID_PCACHE_NAME );
$parserCache->deleteOptionsKey( $page );
$parsoidCache->deleteOptionsKey( $page );
$rev = $this->makeRevision( $page->getTitle(), $update, $user, 'rev', null );
$rev->setTimestamp( '20100101000000' );
$rev->setParentId( $page->getLatest() );
$updater = $this->getDerivedPageDataUpdater( $page );
$updater->prepareContent( $user, $update, false );
$rev->setId( 1107 );
$updater->prepareUpdate( $rev );
// Force the page timestamp, so we notice whether ParserOutput::getTimestamp
// or ParserOutput::getCacheTime are used.
// Also ensure $page->getLatest() returns the correct revision ID, so the parser
// cache doesn't get confused.
TestingAccessWrapper::newFromObject( $page )->setLastEdit( $rev );
$updater->doParserCacheUpdate();
// The cached ParserOutput should not use the revision timestamp
$cached = $parserCache->get( $page, $updater->getCanonicalParserOptions(), true );
$this->assertIsObject( $cached );
}
/**
* Helper for testTemplateUpdate
*
* @param WikiPage $page
* @param string $content
*/
private function editAndUpdate( $page, $content ) {
$this->createRevision( $page, $content );
$this->getServiceContainer()->resetServiceForTesting( 'BacklinkCacheFactory' );
$this->runJobs();
}
/**
* Regression test for T368006
*/
public function testTemplateUpdate() {
$clock = MWTimestamp::convert( TS_UNIX, '20100101000000' );
MWTimestamp::setFakeTime( static function () use ( &$clock ) {
return $clock++;
} );
$template = $this->getPage( 'Template:TestTemplateUpdate' );
$page = $this->getPage( 'TestTemplateUpdate' );
$this->editAndUpdate( $template, '1' );
$this->editAndUpdate( $page, '{{TestTemplateUpdate}}' );
$oldTouched = $page->getTouched();
$page->clear();
$this->editAndUpdate( $template, '2' );
$newTouched = $page->getTouched();
$this->assertGreaterThan( $oldTouched, $newTouched );
}
}
PK ! n2@ @ - Storage/PageUpdaterFactoryIntegrationTest.phpnu Iw getExistingTestPage();
$title = $page->getTitle();
$user = $this->getTestUser()->getUserIdentity();
/** @var TextContent $content */
$content = ContentHandler::makeContent(
"[[Lorem ipsum]] dolor sit amet, consetetur sadipscing elitr, sed diam "
. " nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat.",
$title,
CONTENT_MODEL_WIKITEXT
);
$factory = $this->getServiceContainer()->getPageUpdaterFactory();
$updater = $factory->newPageUpdater( $page, $user );
$updater->setContent( SlotRecord::MAIN, $content );
$update = $updater->prepareUpdate();
/** @var TextContent $pstContent */
$pstContent = $update->getRawContent( SlotRecord::MAIN );
$this->assertSame( $content->getText(), $pstContent->getText() );
$pout = $update->getCanonicalParserOutput();
$this->assertStringContainsString( 'dolor sit amet', $pout->getRawText() );
}
}
PK ! I[, , Storage/NameTableStoreTest.phpnu Iw $name ];
}
$this->getDb()->newInsertQueryBuilder()
->insertInto( 'slot_roles' )
->rows( $insertValues )
->caller( __METHOD__ )
->execute();
}
private function getHashWANObjectCache( $cacheBag ) {
return new WANObjectCache( [ 'cache' => $cacheBag ] );
}
/**
* @param IDatabase $db
* @return LoadBalancer
*/
private function getMockLoadBalancer( $db ) {
$mock = $this->createMock( LoadBalancer::class );
$mock->method( 'getConnection' )->willReturn( $db );
return $mock;
}
/**
* @param int $insertCalls
* @param int $selectCalls
* @param int $selectFieldCalls
*
* @return MockObject&IDatabase
*/
private function getProxyDb( $insertCalls, $selectCalls, $selectFieldCalls ) {
$proxiedMethods = [
'select' => $selectCalls,
'insert' => $insertCalls,
'selectField' => $selectFieldCalls,
'affectedRows' => null,
'insertId' => null,
'getSessionLagStatus' => null,
'onTransactionPreCommitOrIdle' => null,
'doAtomicSection' => null,
'begin' => null,
'rollback' => null,
'commit' => null,
];
$mock = $this->createMock( IDatabase::class );
foreach ( $proxiedMethods as $method => $count ) {
$mock->expects( is_int( $count ) ? $this->exactly( $count ) : $this->any() )
->method( $method )
->willReturnCallback( function ( ...$args ) use ( $method ) {
return $this->getDb()->$method( ...$args );
} );
}
$mock->method( 'newSelectQueryBuilder' )->willReturnCallback( static fn () => new SelectQueryBuilder( $mock ) );
$mock->method( 'newInsertQueryBuilder' )->willReturnCallback( static fn () => new InsertQueryBuilder( $mock ) );
return $mock;
}
private function getNameTableSqlStore(
BagOStuff $cacheBag,
$insertCalls,
$selectCalls,
$selectFieldCalls,
$normalizationCallback = null,
$insertCallback = null
) {
return new NameTableStore(
$this->getMockLoadBalancer(
$this->getProxyDb( $insertCalls, $selectCalls, $selectFieldCalls )
),
$this->getHashWANObjectCache( $cacheBag ),
new NullLogger(),
'slot_roles', 'role_id', 'role_name',
$normalizationCallback,
false,
$insertCallback
);
}
public static function provideGetAndAcquireId() {
return [
'no wancache, empty table' =>
[ new EmptyBagOStuff(), true, 1, [], 'foo', 1 ],
'no wancache, one matching value' =>
[ new EmptyBagOStuff(), false, 1, [ 'foo' ], 'foo', 1 ],
'no wancache, one not matching value' =>
[ new EmptyBagOStuff(), true, 1, [ 'bar' ], 'foo', 2 ],
'no wancache, multiple, one matching value' =>
[ new EmptyBagOStuff(), false, 1, [ 'foo', 'bar' ], 'bar', 2 ],
'no wancache, multiple, no matching value' =>
[ new EmptyBagOStuff(), true, 1, [ 'foo', 'bar' ], 'baz', 3 ],
'wancache, empty table' =>
[ new HashBagOStuff(), true, 1, [], 'foo', 1 ],
'wancache, one matching value' =>
[ new HashBagOStuff(), false, 1, [ 'foo' ], 'foo', 1 ],
'wancache, one not matching value' =>
[ new HashBagOStuff(), true, 1, [ 'bar' ], 'foo', 2 ],
'wancache, multiple, one matching value' =>
[ new HashBagOStuff(), false, 1, [ 'foo', 'bar' ], 'bar', 2 ],
'wancache, multiple, no matching value' =>
[ new HashBagOStuff(), true, 1, [ 'foo', 'bar' ], 'baz', 3 ],
];
}
/**
* @dataProvider provideGetAndAcquireId
* @param BagOStuff $cacheBag to use in the WANObjectCache service
* @param bool $needsInsert Does the value we are testing need to be inserted?
* @param int $selectCalls Number of times the select DB method will be called
* @param string[] $existingValues to be added to the db table
* @param string $name name to acquire
* @param int $expectedId the id we expect the name to have
*/
public function testGetAndAcquireId(
$cacheBag,
$needsInsert,
$selectCalls,
$existingValues,
$name,
$expectedId
) {
$this->populateTable( $existingValues );
$store = $this->getNameTableSqlStore( $cacheBag, (int)$needsInsert, $selectCalls, 0 );
// Some names will not initially exist
try {
$result = $store->getId( $name );
$this->assertSame( $expectedId, $result );
} catch ( NameTableAccessException $e ) {
if ( $needsInsert ) {
$this->assertTrue( true ); // Expected exception
} else {
$this->fail( 'Did not expect an exception, but got one: ' . $e->getMessage() );
}
}
// All names should return their id here
$this->assertSame( $expectedId, $store->acquireId( $name ) );
// acquireId inserted these names, so now everything should exist with getId
$this->assertSame( $expectedId, $store->getId( $name ) );
// calling getId again will also still work, and not result in more selects
$this->assertSame( $expectedId, $store->getId( $name ) );
}
public static function provideTestGetAndAcquireIdNameNormalization() {
yield [ 'A', 'a', 'strtolower' ];
yield [ 'b', 'B', 'strtoupper' ];
yield [ 'X', 'X', static fn ( $name ) => $name ];
yield [ 'ZZ', 'ZZ-a', static fn ( $name ) => "$name-a" ];
}
/**
* @dataProvider provideTestGetAndAcquireIdNameNormalization
*/
public function testGetAndAcquireIdNameNormalization(
$nameIn,
$nameOut,
$normalizationCallback
) {
$store = $this->getNameTableSqlStore(
new EmptyBagOStuff(),
1,
1,
0,
$normalizationCallback
);
$acquiredId = $store->acquireId( $nameIn );
$this->assertSame( $nameOut, $store->getName( $acquiredId ) );
}
public static function provideGetName() {
return [
[ new HashBagOStuff(), 3, 2 ],
[ new EmptyBagOStuff(), 3, 3 ],
];
}
/**
* @dataProvider provideGetName
*/
public function testGetName( BagOStuff $cacheBag, $insertCalls, $selectCalls ) {
$now = microtime( true );
$cacheBag->setMockTime( $now );
// Check for operations to in-memory cache (IMC) and persistent cache (PC)
$store = $this->getNameTableSqlStore( $cacheBag, $insertCalls, $selectCalls, 0 );
// Get 1 ID and make sure getName returns correctly
$fooId = $store->acquireId( 'foo' ); // regen PC, set IMC, update IMC, tombstone PC
$now += 0.01;
$this->assertSame( 'foo', $store->getName( $fooId ) ); // use IMC
$now += 0.01;
// Get another ID and make sure getName returns correctly
$barId = $store->acquireId( 'bar' ); // update IMC, tombstone PC
$now += 0.01;
$this->assertSame( 'bar', $store->getName( $barId ) ); // use IMC
$now += 0.01;
// Blitz the cache and make sure it still returns
TestingAccessWrapper::newFromObject( $store )->tableCache = null; // clear IMC
$this->assertSame( 'foo', $store->getName( $fooId ) ); // regen interim PC, set IMC
$this->assertSame( 'bar', $store->getName( $barId ) ); // use IMC
// Blitz the cache again and get another ID and make sure getName returns correctly
TestingAccessWrapper::newFromObject( $store )->tableCache = null; // clear IMC
$bazId = $store->acquireId( 'baz' ); // set IMC using interim PC, update IMC, tombstone PC
$now += 0.01;
$this->assertSame( 'baz', $store->getName( $bazId ) ); // uses IMC
$this->assertSame( 'baz', $store->getName( $bazId ) ); // uses IMC
}
public function testGetName_masterFallback() {
$store = $this->getNameTableSqlStore( new EmptyBagOStuff(), 1, 2, 0 );
// Insert a new name
$fooId = $store->acquireId( 'foo' );
// Empty the process cache, getCachedTable() will now return this empty array
TestingAccessWrapper::newFromObject( $store )->tableCache = [];
// getName should fallback to master, which is why we assert 2 selectCalls above
$this->assertSame( 'foo', $store->getName( $fooId ) );
}
public function testGetMap_empty() {
$this->populateTable( [] );
$store = $this->getNameTableSqlStore( new HashBagOStuff(), 0, 1, 0 );
$table = $store->getMap();
$this->assertSame( [], $table );
}
public function testGetMap_twoValues() {
$this->populateTable( [ 'foo', 'bar' ] );
$store = $this->getNameTableSqlStore( new HashBagOStuff(), 0, 1, 0 );
// We are using a cache, so 2 calls should only result in 1 select on the db
$store->getMap();
$table = $store->getMap();
$expected = [ 1 => 'foo', 2 => 'bar' ];
$this->assertSame( $expected, $table );
// Make sure the table returned is the same as the cached table
$this->assertSame( $expected, TestingAccessWrapper::newFromObject( $store )->tableCache );
}
public function testReloadMap() {
$this->populateTable( [ 'foo' ] );
$store = $this->getNameTableSqlStore( new HashBagOStuff(), 0, 2, 0 );
// force load
$this->assertCount( 1, $store->getMap() );
// add more stuff to the table, so the cache gets out of sync
$this->populateTable( [ 'bar' ] );
$expected = [ 1 => 'foo', 2 => 'bar' ];
$this->assertSame( $expected, $store->reloadMap() );
$this->assertSame( $expected, $store->getMap() );
}
public function testCacheRaceCondition() {
$wanHashBag = new HashBagOStuff();
$store1 = $this->getNameTableSqlStore( $wanHashBag, 1, 1, 0 );
$store2 = $this->getNameTableSqlStore( $wanHashBag, 1, 0, 0 );
$store3 = $this->getNameTableSqlStore( $wanHashBag, 2, 0, 2 );
// Cache the current table in the instances we will use
// This simulates multiple requests running simultaneously
$store1->getMap();
$store2->getMap();
$store3->getMap();
// Store 2 separate names using different instances
$fooId = $store1->acquireId( 'foo' );
$barId = $store2->acquireId( 'bar' );
// Each of these instances should be aware of what they have inserted
$this->assertSame( $fooId, $store1->acquireId( 'foo' ) );
$this->assertSame( $barId, $store2->acquireId( 'bar' ) );
// A new store should be able to get both of these new Ids
// Note: before there was a race condition here where acquireId( 'bar' ) would update the
// cache with data missing the 'foo' key that it was not aware of
$store4 = $this->getNameTableSqlStore( $wanHashBag, 0, 1, 0 );
$this->assertSame( $fooId, $store4->getId( 'foo' ) );
$this->assertSame( $barId, $store4->getId( 'bar' ) );
// If a store with old cached data tries to acquire these we will get the same ids.
$this->assertSame( $fooId, $store3->acquireId( 'foo' ) );
$this->assertSame( $barId, $store3->acquireId( 'bar' ) );
}
public function testGetAndAcquireIdInsertCallback() {
// Postgres does not allow to specify the SERIAL column on insert to fake an id
$this->markTestSkippedIfDbType( 'postgres' );
$store = $this->getNameTableSqlStore(
new EmptyBagOStuff(),
1,
1,
0,
null,
static function ( $insertFields ) {
$insertFields['role_id'] = 7251;
return $insertFields;
}
);
$this->assertSame( 7251, $store->acquireId( 'A' ) );
}
}
PK ! Tb." " # Storage/RevisionSlotsUpdateTest.phpnu Iw $slotA,
'B' => $slotB,
'C' => $slotC,
] );
$newSlots = new RevisionSlots( [
'A' => $slotA,
'B' => $slotB2,
] );
yield [ $newSlots, null, [ 'A', 'B' ], [] ];
yield [ $newSlots, $parentSlots, [ 'B' ], [ 'C' ] ];
}
/**
* @dataProvider provideNewFromRevisionSlots
*/
public function testNewFromRevisionSlots(
RevisionSlots $newSlots,
?RevisionSlots $parentSlots,
array $modified,
array $removed
) {
$update = RevisionSlotsUpdate::newFromRevisionSlots( $newSlots, $parentSlots );
$this->assertEquals( $modified, $update->getModifiedRoles() );
$this->assertEquals( $removed, $update->getRemovedRoles() );
foreach ( $modified as $role ) {
$this->assertSame( $newSlots->getSlot( $role ), $update->getModifiedSlot( $role ) );
}
}
public static function provideNewFromContent() {
$slotA = SlotRecord::newUnsaved( 'A', new WikitextContent( 'A' ) );
$slotB = SlotRecord::newUnsaved( 'B', new WikitextContent( 'B' ) );
$slotC = SlotRecord::newUnsaved( 'C', new WikitextContent( 'C' ) );
$parentSlots = new RevisionSlots( [
'A' => $slotA,
'B' => $slotB,
'C' => $slotC,
] );
$newContent = [
'A' => new WikitextContent( 'A' ),
'B' => new WikitextContent( 'B2' ),
];
yield [ $newContent, null, [ 'A', 'B' ] ];
yield [ $newContent, $parentSlots, [ 'B' ] ];
}
/**
* @dataProvider provideNewFromContent
*/
public function testNewFromContent(
array $newContent,
?RevisionSlots $parentSlots = null,
array $modified = []
) {
$update = RevisionSlotsUpdate::newFromContent( $newContent, $parentSlots );
$this->assertEquals( $modified, $update->getModifiedRoles() );
$this->assertSame( [], $update->getRemovedRoles() );
}
public function testConstructor() {
$update = new RevisionSlotsUpdate();
$this->assertSame( [], $update->getModifiedRoles() );
$this->assertSame( [], $update->getRemovedRoles() );
$slotA = SlotRecord::newUnsaved( 'A', new WikitextContent( 'A' ) );
$update = new RevisionSlotsUpdate( [ 'A' => $slotA ] );
$this->assertEquals( [ 'A' ], $update->getModifiedRoles() );
$this->assertSame( [], $update->getRemovedRoles() );
$update = new RevisionSlotsUpdate( [ 'A' => $slotA ], [ 'X' ] );
$this->assertEquals( [ 'A' ], $update->getModifiedRoles() );
$this->assertEquals( [ 'X' ], $update->getRemovedRoles() );
}
public function testModifySlot() {
$slots = new RevisionSlotsUpdate();
$this->assertSame( [], $slots->getModifiedRoles() );
$this->assertSame( [], $slots->getRemovedRoles() );
$slotA = SlotRecord::newUnsaved( 'some', new WikitextContent( 'A' ) );
$slots->modifySlot( $slotA );
$this->assertTrue( $slots->isModifiedSlot( 'some' ) );
$this->assertFalse( $slots->isRemovedSlot( 'some' ) );
$this->assertSame( $slotA, $slots->getModifiedSlot( 'some' ) );
$this->assertSame( [ 'some' ], $slots->getModifiedRoles() );
$this->assertSame( [], $slots->getRemovedRoles() );
$slotB = SlotRecord::newUnsaved( 'other', new WikitextContent( 'B' ) );
$slots->modifySlot( $slotB );
$this->assertTrue( $slots->isModifiedSlot( 'other' ) );
$this->assertFalse( $slots->isRemovedSlot( 'other' ) );
$this->assertSame( $slotB, $slots->getModifiedSlot( 'other' ) );
$this->assertSame( [ 'some', 'other' ], $slots->getModifiedRoles() );
$this->assertSame( [], $slots->getRemovedRoles() );
// modify slot A again
$slots->modifySlot( $slotA );
$this->assertArrayEquals( [ 'some', 'other' ], $slots->getModifiedRoles() );
// remove modified slot
$slots->removeSlot( 'some' );
$this->assertSame( [ 'other' ], $slots->getModifiedRoles() );
$this->assertSame( [ 'some' ], $slots->getRemovedRoles() );
// modify removed slot
$slots->modifySlot( $slotA );
$this->assertArrayEquals( [ 'some', 'other' ], $slots->getModifiedRoles() );
$this->assertSame( [], $slots->getRemovedRoles() );
}
public function testRemoveSlot() {
$slots = new RevisionSlotsUpdate();
$slotA = SlotRecord::newUnsaved( SlotRecord::MAIN, new WikitextContent( 'A' ) );
$slots->modifySlot( $slotA );
$this->assertSame( [ SlotRecord::MAIN ], $slots->getModifiedRoles() );
$slots->removeSlot( SlotRecord::MAIN );
$slots->removeSlot( 'other' );
$this->assertSame( [], $slots->getModifiedRoles() );
$this->assertSame( [ SlotRecord::MAIN, 'other' ], $slots->getRemovedRoles() );
$this->assertTrue( $slots->isRemovedSlot( SlotRecord::MAIN ) );
$this->assertTrue( $slots->isRemovedSlot( 'other' ) );
$this->assertFalse( $slots->isModifiedSlot( SlotRecord::MAIN ) );
// removing the same slot again should not trigger an error
$slots->removeSlot( SlotRecord::MAIN );
// getting a slot after removing it should fail
$this->expectException( RevisionAccessException::class );
$slots->getModifiedSlot( SlotRecord::MAIN );
}
public function testGetModifiedRoles() {
$slots = new RevisionSlotsUpdate( [], [ 'xyz' ] );
$this->assertSame( [], $slots->getModifiedRoles() );
$slots->modifyContent( SlotRecord::MAIN, new WikitextContent( 'A' ) );
$slots->modifyContent( 'foo', new WikitextContent( 'Foo' ) );
$this->assertSame( [ SlotRecord::MAIN, 'foo' ], $slots->getModifiedRoles() );
$slots->removeSlot( SlotRecord::MAIN );
$this->assertSame( [ 'foo' ], $slots->getModifiedRoles() );
}
public function testGetRemovedRoles() {
$slotA = SlotRecord::newUnsaved( SlotRecord::MAIN, new WikitextContent( 'A' ) );
$slots = new RevisionSlotsUpdate( [ $slotA ] );
$this->assertSame( [], $slots->getRemovedRoles() );
$slots->removeSlot( SlotRecord::MAIN, new WikitextContent( 'A' ) );
$slots->removeSlot( 'foo', new WikitextContent( 'Foo' ) );
$this->assertSame( [ SlotRecord::MAIN, 'foo' ], $slots->getRemovedRoles() );
$slots->modifyContent( SlotRecord::MAIN, new WikitextContent( 'A' ) );
$this->assertSame( [ 'foo' ], $slots->getRemovedRoles() );
}
public static function provideHasSameUpdates() {
$fooX = SlotRecord::newUnsaved( 'x', new WikitextContent( 'Foo' ) );
$barZ = SlotRecord::newUnsaved( 'z', new WikitextContent( 'Bar' ) );
$a = new RevisionSlotsUpdate();
$a->modifySlot( $fooX );
$a->modifySlot( $barZ );
$a->removeSlot( 'Q' );
$a2 = new RevisionSlotsUpdate();
$a2->modifySlot( $fooX );
$a2->modifySlot( $barZ );
$a2->removeSlot( 'Q' );
$b = new RevisionSlotsUpdate();
$b->modifySlot( $barZ );
$b->removeSlot( 'Q' );
$c = new RevisionSlotsUpdate();
$c->modifySlot( $fooX );
$c->modifySlot( $barZ );
yield 'same instance' => [ $a, $a, true ];
yield 'same udpates' => [ $a, $a2, true ];
yield 'different modified' => [ $a, $b, false ];
yield 'different removed' => [ $a, $c, false ];
}
/**
* @dataProvider provideHasSameUpdates
*/
public function testHasSameUpdates( RevisionSlotsUpdate $a, RevisionSlotsUpdate $b, $same ) {
$this->assertSame( $same, $a->hasSameUpdates( $b ) );
$this->assertSame( $same, $b->hasSameUpdates( $a ) );
}
/**
* @param string $role
* @param Content $content
* @return SlotRecord
*/
private function newSavedSlot( $role, Content $content ) {
return SlotRecord::newSaved( 7, 7, 'xyz', SlotRecord::newUnsaved( $role, $content ) );
}
public function testApplyUpdate() {
/** @var SlotRecord[] $parentSlots */
$parentSlots = [
'X' => $this->newSavedSlot( 'X', new WikitextContent( 'X' ) ),
'Y' => $this->newSavedSlot( 'Y', new WikitextContent( 'Y' ) ),
'Z' => $this->newSavedSlot( 'Z', new WikitextContent( 'Z' ) ),
];
$slots = MutableRevisionSlots::newFromParentRevisionSlots( $parentSlots );
$update = RevisionSlotsUpdate::newFromContent( [
'A' => new WikitextContent( 'A' ),
'Y' => new WikitextContent( 'yyy' ),
] );
$update->removeSlot( 'Z' );
$update->apply( $slots );
$this->assertSame( [ 'X', 'Y', 'A' ], $slots->getSlotRoles() );
$this->assertSame( $update->getModifiedSlot( 'A' ), $slots->getSlot( 'A' ) );
$this->assertSame( $update->getModifiedSlot( 'Y' ), $slots->getSlot( 'Y' ) );
}
}
PK ! I:dP P " logging/UploadLogFormatterTest.phpnu Iw 'upload',
'action' => 'upload',
'comment' => 'upload comment',
'namespace' => NS_FILE,
'title' => 'File.png',
'params' => [
'img_sha1' => 'hash',
'img_timestamp' => '20150101000000',
],
],
[
'text' => 'User uploaded File:File.png',
'api' => [
'img_sha1' => 'hash',
'img_timestamp' => '2015-01-01T00:00:00Z',
],
],
],
// Old format without params
[
[
'type' => 'upload',
'action' => 'upload',
'comment' => 'upload comment',
'namespace' => NS_FILE,
'title' => 'File.png',
'params' => [],
],
[
'text' => 'User uploaded File:File.png',
'api' => [],
],
],
];
}
/**
* @dataProvider provideUploadLogDatabaseRows
*/
public function testUploadLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideOverwriteLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'upload',
'action' => 'overwrite',
'comment' => 'upload comment',
'namespace' => NS_FILE,
'title' => 'File.png',
'params' => [
'img_sha1' => 'hash',
'img_timestamp' => '20150101000000',
],
],
[
'text' => 'User uploaded a new version of File:File.png',
'api' => [
'img_sha1' => 'hash',
'img_timestamp' => '2015-01-01T00:00:00Z',
],
],
],
// Old format without params
[
[
'type' => 'upload',
'action' => 'overwrite',
'comment' => 'upload comment',
'namespace' => NS_FILE,
'title' => 'File.png',
'params' => [],
],
[
'text' => 'User uploaded a new version of File:File.png',
'api' => [],
],
],
];
}
/**
* @dataProvider provideOverwriteLogDatabaseRows
*/
public function testOverwriteLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideRevertLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'upload',
'action' => 'revert',
'comment' => 'upload comment',
'namespace' => NS_FILE,
'title' => 'File.png',
'params' => [
'img_sha1' => 'hash',
'img_timestamp' => '20150101000000',
],
],
[
'text' => 'User reverted File:File.png to an old version',
'api' => [
'img_sha1' => 'hash',
'img_timestamp' => '2015-01-01T00:00:00Z',
],
],
],
// Old format without params
[
[
'type' => 'upload',
'action' => 'revert',
'comment' => 'upload comment',
'namespace' => NS_FILE,
'title' => 'File.png',
'params' => [],
],
[
'text' => 'User reverted File:File.png to an old version',
'api' => [],
],
],
];
}
/**
* @dataProvider provideRevertLogDatabaseRows
*/
public function testRevertLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
}
PK ! V&2NO NO " logging/DeleteLogFormatterTest.phpnu Iw 'delete',
'action' => 'delete',
'comment' => 'delete comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [],
],
[
'text' => 'User deleted page Page',
'api' => [],
],
],
// Legacy format
[
[
'type' => 'delete',
'action' => 'delete',
'comment' => 'delete comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [],
],
[
'legacy' => true,
'text' => 'User deleted page Page',
'api' => [],
],
],
];
}
/**
* @dataProvider provideDeleteLogDatabaseRows
*/
public function testDeleteLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideRestoreLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'delete',
'action' => 'restore',
'comment' => 'delete comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
':assoc:count' => [
'revisions' => 2,
'files' => 1,
],
],
],
[
'text' => 'User undeleted page Page (2 revisions and 1 file)',
'api' => [
'count' => [
'revisions' => 2,
'files' => 1,
],
],
],
],
// Legacy format without counts
[
[
'type' => 'delete',
'action' => 'restore',
'comment' => 'delete comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [],
],
[
'text' => 'User undeleted page Page',
'api' => [],
],
],
// Legacy format
[
[
'type' => 'delete',
'action' => 'restore',
'comment' => 'delete comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [],
],
[
'legacy' => true,
'text' => 'User undeleted page Page',
'api' => [],
],
],
];
}
/**
* @dataProvider provideRestoreLogDatabaseRows
*/
public function testRestoreLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideRevisionLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'delete',
'action' => 'revision',
'comment' => 'delete comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'4::type' => 'archive',
'5::ids' => [ '1', '3', '4' ],
'6::ofield' => '1',
'7::nfield' => '2',
],
],
[
'text' => 'User changed visibility of 3 revisions on page Page: edit summary '
. 'hidden and content unhidden',
'api' => [
'type' => 'archive',
'ids' => [ '1', '3', '4' ],
'old' => [
'bitmask' => 1,
'content' => true,
'comment' => false,
'user' => false,
'restricted' => false,
],
'new' => [
'bitmask' => 2,
'content' => false,
'comment' => true,
'user' => false,
'restricted' => false,
],
],
],
],
// Legacy format
[
[
'type' => 'delete',
'action' => 'revision',
'comment' => 'delete comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'archive',
'1,3,4',
'ofield=1',
'nfield=2',
],
],
[
'legacy' => true,
'text' => 'User changed visibility of 3 revisions on page Page: edit summary '
. 'hidden and content unhidden',
'api' => [
'type' => 'archive',
'ids' => [ '1', '3', '4' ],
'old' => [
'bitmask' => 1,
'content' => true,
'comment' => false,
'user' => false,
'restricted' => false,
],
'new' => [
'bitmask' => 2,
'content' => false,
'comment' => true,
'user' => false,
'restricted' => false,
],
],
],
],
// Legacy format pre-T20361, the changes part of the comment
[
[
'type' => 'delete',
'action' => 'revision',
'comment' => 'edit summary hidden and content unhidden: delete comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'archive',
'1,3,4',
],
],
[
'legacy' => true,
'text' => 'User changed visibility of revisions on page Page',
'api' => [
'type' => 'archive',
'ids' => [ '1', '3', '4' ],
],
],
],
];
}
/**
* @dataProvider provideRevisionLogDatabaseRows
*/
public function testRevisionLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideEventLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'delete',
'action' => 'event',
'comment' => 'delete comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'4::ids' => [ '1', '3', '4' ],
'5::ofield' => '1',
'6::nfield' => '2',
],
],
[
'text' => 'User changed visibility of 3 log events on Page: edit summary hidden '
. 'and content unhidden',
'api' => [
'type' => 'logging',
'ids' => [ '1', '3', '4' ],
'old' => [
'bitmask' => 1,
'content' => true,
'comment' => false,
'user' => false,
'restricted' => false,
],
'new' => [
'bitmask' => 2,
'content' => false,
'comment' => true,
'user' => false,
'restricted' => false,
],
],
],
],
// Legacy format
[
[
'type' => 'delete',
'action' => 'event',
'comment' => 'delete comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'1,3,4',
'ofield=1',
'nfield=2',
],
],
[
'legacy' => true,
'text' => 'User changed visibility of 3 log events on Page: edit summary hidden '
. 'and content unhidden',
'api' => [
'type' => 'logging',
'ids' => [ '1', '3', '4' ],
'old' => [
'bitmask' => 1,
'content' => true,
'comment' => false,
'user' => false,
'restricted' => false,
],
'new' => [
'bitmask' => 2,
'content' => false,
'comment' => true,
'user' => false,
'restricted' => false,
],
],
],
],
// Legacy format pre-T20361, the changes part of the comment
[
[
'type' => 'delete',
'action' => 'event',
'comment' => 'edit summary hidden and content unhidden: delete comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'1,3,4',
],
],
[
'legacy' => true,
'text' => 'User changed visibility of log events on Page',
'api' => [
'type' => 'logging',
'ids' => [ '1', '3', '4' ],
],
],
],
];
}
/**
* @dataProvider provideEventLogDatabaseRows
*/
public function testEventLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideSuppressRevisionLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'suppress',
'action' => 'revision',
'comment' => 'Suppress comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'4::type' => 'archive',
'5::ids' => [ '1', '3', '4' ],
'6::ofield' => '1',
'7::nfield' => '10',
],
],
[
'text' => 'User secretly changed visibility of 3 revisions on page Page: edit '
. 'summary hidden, content unhidden and applied restrictions to administrators',
'api' => [
'type' => 'archive',
'ids' => [ '1', '3', '4' ],
'old' => [
'bitmask' => 1,
'content' => true,
'comment' => false,
'user' => false,
'restricted' => false,
],
'new' => [
'bitmask' => 10,
'content' => false,
'comment' => true,
'user' => false,
'restricted' => true,
],
],
],
],
// Legacy format
[
[
'type' => 'suppress',
'action' => 'revision',
'comment' => 'Suppress comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'archive',
'1,3,4',
'ofield=1',
'nfield=10',
],
],
[
'legacy' => true,
'text' => 'User secretly changed visibility of 3 revisions on page Page: edit '
. 'summary hidden, content unhidden and applied restrictions to administrators',
'api' => [
'type' => 'archive',
'ids' => [ '1', '3', '4' ],
'old' => [
'bitmask' => 1,
'content' => true,
'comment' => false,
'user' => false,
'restricted' => false,
],
'new' => [
'bitmask' => 10,
'content' => false,
'comment' => true,
'user' => false,
'restricted' => true,
],
],
],
],
// Legacy format pre-T20361, the changes part of the comment
[
[
'type' => 'suppress',
'action' => 'revision',
'comment' => 'edit summary hidden, content unhidden and applied restrictions to administrators: '
. 'Suppress comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'archive',
'1,3,4',
],
],
[
'legacy' => true,
'text' => 'User secretly changed visibility of revisions on page Page',
'api' => [
'type' => 'archive',
'ids' => [ '1', '3', '4' ],
],
],
],
];
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideSuppressRevisionLogDatabaseRowsNonPrivileged() {
return [
// Current format
[
[
'type' => 'suppress',
'action' => 'revision',
'comment' => 'Suppress comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'4::type' => 'archive',
'5::ids' => [ '1', '3', '4' ],
'6::ofield' => '1',
'7::nfield' => '10',
],
],
[
'text' => '(username removed) (log details removed)',
'api' => [
'type' => 'archive',
'ids' => [ '1', '3', '4' ],
'old' => [
'bitmask' => 1,
'content' => true,
'comment' => false,
'user' => false,
'restricted' => false,
],
'new' => [
'bitmask' => 10,
'content' => false,
'comment' => true,
'user' => false,
'restricted' => true,
],
],
],
],
// Legacy format
[
[
'type' => 'suppress',
'action' => 'revision',
'comment' => 'Suppress comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'archive',
'1,3,4',
'ofield=1',
'nfield=10',
],
],
[
'legacy' => true,
'text' => '(username removed) (log details removed)',
'api' => [
'type' => 'archive',
'ids' => [ '1', '3', '4' ],
'old' => [
'bitmask' => 1,
'content' => true,
'comment' => false,
'user' => false,
'restricted' => false,
],
'new' => [
'bitmask' => 10,
'content' => false,
'comment' => true,
'user' => false,
'restricted' => true,
],
],
],
],
// Legacy format pre-T20361, the changes part of the comment
[
[
'type' => 'suppress',
'action' => 'revision',
'comment' => 'Suppress comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'archive',
'1,3,4',
],
],
[
'legacy' => true,
'text' => '(username removed) (log details removed)',
'api' => [
'type' => 'archive',
'ids' => [ '1', '3', '4' ],
],
],
],
];
}
/**
* @dataProvider provideSuppressRevisionLogDatabaseRowsNonPrivileged
*/
public function testSuppressRevisionLogDatabaseRowsNonPrivileged( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideSuppressEventLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'suppress',
'action' => 'event',
'comment' => 'Suppress comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'4::ids' => [ '1', '3', '4' ],
'5::ofield' => '1',
'6::nfield' => '10',
],
],
[
'text' => 'User secretly changed visibility of 3 log events on Page: edit '
. 'summary hidden, content unhidden and applied restrictions to administrators',
'api' => [
'type' => 'logging',
'ids' => [ '1', '3', '4' ],
'old' => [
'bitmask' => 1,
'content' => true,
'comment' => false,
'user' => false,
'restricted' => false,
],
'new' => [
'bitmask' => 10,
'content' => false,
'comment' => true,
'user' => false,
'restricted' => true,
],
],
],
],
// Legacy formats
[
[
'type' => 'suppress',
'action' => 'event',
'comment' => 'Suppress comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'1,3,4',
'ofield=1',
'nfield=10',
],
],
[
'legacy' => true,
'text' => 'User secretly changed visibility of 3 log events on Page: edit '
. 'summary hidden, content unhidden and applied restrictions to administrators',
'api' => [
'type' => 'logging',
'ids' => [ '1', '3', '4' ],
'old' => [
'bitmask' => 1,
'content' => true,
'comment' => false,
'user' => false,
'restricted' => false,
],
'new' => [
'bitmask' => 10,
'content' => false,
'comment' => true,
'user' => false,
'restricted' => true,
],
],
],
],
// Legacy format pre-T20361, the changes part of the comment
[
[
'type' => 'delete',
'action' => 'revision',
'comment' => 'Old rows might lack ofield/nfield (T224815)',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'oldid',
'1234',
],
],
[
'legacy' => true,
'text' => 'User changed visibility of revisions on page Page',
'api' => [
'type' => 'oldid',
'ids' => [ '1234' ],
],
],
]
];
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideSuppressEventLogDatabaseRowsNonPrivileged() {
return [
// Current format
[
[
'type' => 'suppress',
'action' => 'event',
'comment' => 'Suppress comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'4::ids' => [ '1', '3', '4' ],
'5::ofield' => '1',
'6::nfield' => '10',
],
],
[
'text' => '(username removed) (log details removed)',
'api' => [
'type' => 'logging',
'ids' => [ '1', '3', '4' ],
'old' => [
'bitmask' => 1,
'content' => true,
'comment' => false,
'user' => false,
'restricted' => false,
],
'new' => [
'bitmask' => 10,
'content' => false,
'comment' => true,
'user' => false,
'restricted' => true,
],
],
],
],
// Legacy format
[
[
'type' => 'suppress',
'action' => 'event',
'comment' => 'Suppress comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'1,3,4',
'ofield=1',
'nfield=10',
],
],
[
'legacy' => true,
'text' => '(username removed) (log details removed)',
'api' => [
'type' => 'logging',
'ids' => [ '1', '3', '4' ],
'old' => [
'bitmask' => 1,
'content' => true,
'comment' => false,
'user' => false,
'restricted' => false,
],
'new' => [
'bitmask' => 10,
'content' => false,
'comment' => true,
'user' => false,
'restricted' => true,
],
],
],
],
// Legacy format pre-T20361, the changes part of the comment
[
[
'type' => 'suppress',
'action' => 'event',
'comment' => 'Suppress comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'1,3,4',
],
],
[
'legacy' => true,
'text' => '(username removed) (log details removed)',
'api' => [
'type' => 'logging',
'ids' => [ '1', '3', '4' ],
],
],
],
];
}
/**
* @dataProvider provideSuppressEventLogDatabaseRowsNonPrivileged
*/
public function testSuppressEventLogDatabaseRowsNonPrivileged( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideSuppressDeleteLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'suppress',
'action' => 'delete',
'comment' => 'delete comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [],
],
[
'text' => 'User suppressed page Page',
'api' => [],
],
],
// Legacy format
[
[
'type' => 'suppress',
'action' => 'delete',
'comment' => 'delete comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [],
],
[
'legacy' => true,
'text' => 'User suppressed page Page',
'api' => [],
],
],
];
}
/**
* @dataProvider provideSuppressRevisionLogDatabaseRows
* @dataProvider provideSuppressEventLogDatabaseRows
* @dataProvider provideSuppressDeleteLogDatabaseRows
*/
public function testSuppressLogDatabaseRows( $row, $extra ) {
$this->setGroupPermissions(
[
'oversight' => [
'viewsuppressed' => true,
'suppressionlog' => true,
],
]
);
$this->doTestLogFormatter( $row, $extra, [ 'oversight' ] );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideSuppressDeleteLogDatabaseRowsNonPrivileged() {
return [
// Current format
[
[
'type' => 'suppress',
'action' => 'delete',
'comment' => 'delete comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [],
],
[
'text' => '(username removed) (log details removed)',
'api' => [],
],
],
// Legacy format
[
[
'type' => 'suppress',
'action' => 'delete',
'comment' => 'delete comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [],
],
[
'legacy' => true,
'text' => '(username removed) (log details removed)',
'api' => [],
],
],
];
}
/**
* @dataProvider provideSuppressDeleteLogDatabaseRowsNonPrivileged
*/
public function testSuppressDeleteLogDatabaseRowsNonPrivileged( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
}
PK ! =
" " logging/RightsLogFormatterTest.phpnu Iw createNoOpMock( IDatabase::class, [ 'getInfinity' ] );
$db->method( 'getInfinity' )->willReturn( 'infinity' );
$lbFactory = $this->createMock( LBFactory::class );
$lbFactory->method( 'getReplicaDatabase' )->willReturn( $db );
$this->setService( 'DBLoadBalancerFactory', $lbFactory );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideRightsLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'rights',
'action' => 'rights',
'comment' => 'rights comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'User',
'params' => [
'4::oldgroups' => [],
'5::newgroups' => [ 'sysop', 'bureaucrat' ],
'oldmetadata' => [],
'newmetadata' => [
[ 'expiry' => null ],
[ 'expiry' => '20160101123456' ]
],
],
],
[
'text' => 'Sysop changed group membership for User from (none) to '
. 'bureaucrat (temporary, until 12:34, 1 January 2016) and administrator',
'api' => [
'oldgroups' => [],
'newgroups' => [ 'sysop', 'bureaucrat' ],
'oldmetadata' => [],
'newmetadata' => [
[ 'group' => 'sysop', 'expiry' => 'infinity' ],
[ 'group' => 'bureaucrat', 'expiry' => '2016-01-01T12:34:56Z' ],
],
],
],
],
// Previous format (oldgroups and newgroups as arrays, no metadata)
[
[
'type' => 'rights',
'action' => 'rights',
'comment' => 'rights comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'User',
'params' => [
'4::oldgroups' => [],
'5::newgroups' => [ 'sysop', 'bureaucrat' ],
],
],
[
'text' => 'Sysop changed group membership for User from (none) to '
. 'administrator and bureaucrat',
'api' => [
'oldgroups' => [],
'newgroups' => [ 'sysop', 'bureaucrat' ],
'oldmetadata' => [],
'newmetadata' => [
[ 'group' => 'sysop', 'expiry' => 'infinity' ],
[ 'group' => 'bureaucrat', 'expiry' => 'infinity' ],
],
],
],
],
// Legacy format (oldgroups and newgroups as numeric-keyed strings)
[
[
'type' => 'rights',
'action' => 'rights',
'comment' => 'rights comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'User',
'params' => [
'',
'sysop, bureaucrat',
],
],
[
'legacy' => true,
'text' => 'Sysop changed group membership for User from (none) to '
. 'administrator and bureaucrat',
'api' => [
'oldgroups' => [],
'newgroups' => [ 'sysop', 'bureaucrat' ],
'oldmetadata' => [],
'newmetadata' => [
[ 'group' => 'sysop', 'expiry' => 'infinity' ],
[ 'group' => 'bureaucrat', 'expiry' => 'infinity' ],
],
],
],
],
// Really old entry
[
[
'type' => 'rights',
'action' => 'rights',
'comment' => 'rights comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'User',
'params' => [],
],
[
'legacy' => true,
'text' => 'Sysop changed group membership for User',
'api' => [],
],
],
];
}
/**
* @dataProvider provideRightsLogDatabaseRows
*/
public function testRightsLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideAutopromoteLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'rights',
'action' => 'autopromote',
'comment' => 'rights comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Sysop',
'params' => [
'4::oldgroups' => [ 'sysop' ],
'5::newgroups' => [ 'sysop', 'bureaucrat' ],
],
],
[
'text' => 'Sysop was automatically promoted from administrator to '
. 'administrator and bureaucrat',
'api' => [
'oldgroups' => [ 'sysop' ],
'newgroups' => [ 'sysop', 'bureaucrat' ],
'oldmetadata' => [
[ 'group' => 'sysop', 'expiry' => 'infinity' ],
],
'newmetadata' => [
[ 'group' => 'sysop', 'expiry' => 'infinity' ],
[ 'group' => 'bureaucrat', 'expiry' => 'infinity' ],
],
],
],
],
// Legacy format
[
[
'type' => 'rights',
'action' => 'autopromote',
'comment' => 'rights comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Sysop',
'params' => [
'sysop',
'sysop, bureaucrat',
],
],
[
'legacy' => true,
'text' => 'Sysop was automatically promoted from administrator to '
. 'administrator and bureaucrat',
'api' => [
'oldgroups' => [ 'sysop' ],
'newgroups' => [ 'sysop', 'bureaucrat' ],
'oldmetadata' => [
[ 'group' => 'sysop', 'expiry' => 'infinity' ],
],
'newmetadata' => [
[ 'group' => 'sysop', 'expiry' => 'infinity' ],
[ 'group' => 'bureaucrat', 'expiry' => 'infinity' ],
],
],
],
],
];
}
/**
* @dataProvider provideAutopromoteLogDatabaseRows
*/
public function testAutopromoteLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
}
PK ! ɞX X logging/LogFormatterTest.phpnu Iw overrideConfigValues( [
MainConfigNames::LogTypes => [ 'phpunit' ],
MainConfigNames::LogActionsHandlers => [ 'phpunit/test' => LogFormatter::class,
'phpunit/param' => LogFormatter::class ],
] );
$this->user = User::newFromName( 'Testuser' );
$this->title = Title::makeTitle( NS_MAIN, 'SomeTitle' );
$this->target = Title::makeTitle( NS_MAIN, 'TestTarget' );
$this->context = new RequestContext();
$this->context->setUser( $this->user );
$this->context->setTitle( $this->title );
$this->context->setLanguage( RequestContext::getMain()->getLanguage() );
$this->user_comment = '';
}
public function newLogEntry( $action, $params ) {
$logEntry = new ManualLogEntry( 'phpunit', $action );
$logEntry->setPerformer( $this->user );
$logEntry->setTarget( $this->title );
$logEntry->setComment( 'A very good reason' );
$logEntry->setParameters( $params );
return $logEntry;
}
/**
* @covers \LogFormatter::setShowUserToolLinks
*/
public function testNormalLogParams() {
$entry = $this->newLogEntry( 'test', [] );
$formatter = $this->getServiceContainer()->getLogFormatterFactory()->newFromEntry( $entry );
$formatter->setContext( $this->context );
$formatter->setShowUserToolLinks( false );
$paramsWithoutTools = $formatter->getMessageParametersForTesting();
$formatter2 = $this->getServiceContainer()->getLogFormatterFactory()->newFromEntry( $entry );
$formatter2->setContext( $this->context );
$formatter2->setShowUserToolLinks( true );
$paramsWithTools = $formatter2->getMessageParametersForTesting();
$userLink = Linker::userLink(
$this->user->getId(),
$this->user->getName()
);
$userTools = Linker::userToolLinksRedContribs(
$this->user->getId(),
$this->user->getName(),
$this->user->getEditCount(),
false
);
$titleLink = Linker::link( $this->title, null, [], [] );
// $paramsWithoutTools and $paramsWithTools should be only different
// in index 0
$this->assertEquals( $paramsWithoutTools[1], $paramsWithTools[1] );
$this->assertEquals( $paramsWithoutTools[2], $paramsWithTools[2] );
$this->assertEquals( Message::rawParam( $userLink ), $paramsWithoutTools[0] );
$this->assertEquals( Message::rawParam( $userLink . $userTools ), $paramsWithTools[0] );
$this->assertEquals( $this->user->getName(), $paramsWithoutTools[1] );
$this->assertEquals( Message::rawParam( $titleLink ), $paramsWithoutTools[2] );
}
/**
* @covers \LogFormatter::getActionText
*/
public function testLogParamsTypeRaw() {
$params = [ '4:raw:raw' => Linker::link( $this->title, null, [], [] ) ];
$expected = Linker::link( $this->title, null, [], [] );
$entry = $this->newLogEntry( 'param', $params );
$formatter = $this->getServiceContainer()->getLogFormatterFactory()->newFromEntry( $entry );
$formatter->setContext( $this->context );
$logParam = $formatter->getActionText();
$this->assertEquals( $expected, $logParam );
}
/**
* @covers \LogFormatter::getActionText
*/
public function testLogParamsTypeMsg() {
$params = [ '4:msg:msg' => 'log-description-phpunit' ];
$expected = wfMessage( 'log-description-phpunit' )->text();
$entry = $this->newLogEntry( 'param', $params );
$formatter = $this->getServiceContainer()->getLogFormatterFactory()->newFromEntry( $entry );
$formatter->setContext( $this->context );
$logParam = $formatter->getActionText();
$this->assertEquals( $expected, $logParam );
}
/**
* @covers \LogFormatter::getActionText
*/
public function testLogParamsTypeMsgContent() {
$params = [ '4:msg-content:msgContent' => 'log-description-phpunit' ];
$expected = wfMessage( 'log-description-phpunit' )->inContentLanguage()->text();
$entry = $this->newLogEntry( 'param', $params );
$formatter = $this->getServiceContainer()->getLogFormatterFactory()->newFromEntry( $entry );
$formatter->setContext( $this->context );
$logParam = $formatter->getActionText();
$this->assertEquals( $expected, $logParam );
}
/**
* @covers \LogFormatter::getActionText
*/
public function testLogParamsTypeNumber() {
global $wgLang;
$params = [ '4:number:number' => 123456789 ];
$expected = $wgLang->formatNum( 123456789 );
$entry = $this->newLogEntry( 'param', $params );
$formatter = $this->getServiceContainer()->getLogFormatterFactory()->newFromEntry( $entry );
$formatter->setContext( $this->context );
$logParam = $formatter->getActionText();
$this->assertEquals( $expected, $logParam );
}
/**
* @covers \LogFormatter::getActionText
*/
public function testLogParamsTypeUserLink() {
$params = [ '4:user-link:userLink' => $this->user->getName() ];
$expected = Linker::userLink(
$this->user->getId(),
$this->user->getName()
);
$entry = $this->newLogEntry( 'param', $params );
$formatter = $this->getServiceContainer()->getLogFormatterFactory()->newFromEntry( $entry );
$formatter->setContext( $this->context );
$logParam = $formatter->getActionText();
$this->assertEquals( $expected, $logParam );
}
/**
* @covers \LogFormatter::getActionText
*/
public function testLogParamsTypeUserLink_empty() {
$params = [ '4:user-link:userLink' => ':' ];
$entry = $this->newLogEntry( 'param', $params );
$formatter = $this->getServiceContainer()->getLogFormatterFactory()->newFromEntry( $entry );
$this->context->setLanguage( 'qqx' );
$formatter->setContext( $this->context );
$logParam = $formatter->getActionText();
$this->assertStringContainsString( '(empty-username)', $logParam );
}
/**
* @covers \LogFormatter::getActionText
*/
public function testLogParamsTypeTitleLink() {
$params = [ '4:title-link:titleLink' => $this->title->getText() ];
$expected = Linker::link( $this->title, null, [], [] );
$entry = $this->newLogEntry( 'param', $params );
$formatter = $this->getServiceContainer()->getLogFormatterFactory()->newFromEntry( $entry );
$formatter->setContext( $this->context );
$logParam = $formatter->getActionText();
$this->assertEquals( $expected, $logParam );
}
/**
* @covers \LogFormatter::getActionText
*/
public function testLogParamsTypePlain() {
$params = [ '4:plain:plain' => 'Some plain text' ];
$expected = 'Some plain text';
$entry = $this->newLogEntry( 'param', $params );
$formatter = $this->getServiceContainer()->getLogFormatterFactory()->newFromEntry( $entry );
$formatter->setContext( $this->context );
$logParam = $formatter->getActionText();
$this->assertEquals( $expected, $logParam );
}
/**
* @covers \LogFormatter::getPerformerElement
* @dataProvider provideLogElement
*/
public function testGetPerformerElement( $deletedFlag, $allowedAction ) {
$entry = $this->newLogEntry( 'param', [] );
$entry->setPerformer( new UserIdentityValue( 1328435, 'Test' ) );
if ( $deletedFlag !== 'none' ) {
$entry->setDeleted(
LogPage::DELETED_USER |
( $deletedFlag === 'suppressed' ? LogPage::DELETED_RESTRICTED : 0 )
);
}
$context = new DerivativeContext( $this->context );
if ( $allowedAction !== 'none' ) {
$context->setAuthority( new SimpleAuthority(
$this->context->getUser(),
[ $deletedFlag === 'suppressed' ? 'suppressrevision' : 'deletedhistory' ]
) );
}
$formatter = $this->getServiceContainer()->getLogFormatterFactory()->newFromEntry( $entry );
$formatter->setContext( $context );
if ( $allowedAction === 'view-for-user' ) {
$formatter->setAudience( LogFormatter::FOR_THIS_USER );
}
$element = $formatter->getPerformerElement();
if ( $allowedAction === 'none' ||
( $deletedFlag !== 'none' && $allowedAction === 'view-public' )
) {
$this->assertStringNotContainsString( 'User:Test', $element );
} else {
$this->assertStringContainsString( 'User:Test', $element );
}
if ( $deletedFlag === 'none' ) {
$this->assertStringNotContainsString( 'history-deleted', $element );
} else {
$this->assertStringContainsString( 'history-deleted', $element );
}
if ( $deletedFlag === 'suppressed' ) {
$this->assertStringContainsString( 'mw-history-suppressed', $element );
} else {
$this->assertStringNotContainsString( 'mw-history-suppressed', $element );
}
}
/**
* @covers \LogFormatter::getComment
* @dataProvider provideLogElement
*/
public function testLogComment( $deletedFlag, $allowedAction ) {
$entry = $this->newLogEntry( 'test', [] );
if ( $deletedFlag !== 'none' ) {
$entry->setDeleted(
LogPage::DELETED_COMMENT |
( $deletedFlag === 'suppressed' ? LogPage::DELETED_RESTRICTED : 0 )
);
}
$context = new DerivativeContext( $this->context );
if ( $allowedAction !== 'none' ) {
$context->setAuthority( new SimpleAuthority(
$this->context->getUser(),
[ $deletedFlag === 'suppressed' ? 'suppressrevision' : 'deletedhistory' ]
) );
}
$formatter = $this->getServiceContainer()->getLogFormatterFactory()->newFromEntry( $entry );
$formatter->setContext( $context );
if ( $allowedAction === 'view-for-user' ) {
$formatter->setAudience( LogFormatter::FOR_THIS_USER );
}
$expectedComment = ltrim( $this->getServiceContainer()->getCommentFormatter()->formatBlock( $entry->getComment() ) );
$comment = $formatter->getComment();
if ( $allowedAction === 'none' ||
( $deletedFlag !== 'none' && $allowedAction === 'view-public' )
) {
$this->assertStringNotContainsString( $expectedComment, $comment );
} else {
$this->assertStringContainsString( $expectedComment, $comment );
}
if ( $deletedFlag === 'none' ) {
$this->assertStringNotContainsString( 'history-deleted', $comment );
} else {
$this->assertStringContainsString( 'history-deleted', $comment );
}
if ( $deletedFlag === 'suppressed' ) {
$this->assertStringContainsString( 'mw-history-suppressed', $comment );
} else {
$this->assertStringNotContainsString( 'mw-history-suppressed', $comment );
}
}
public static function provideLogElement() {
return [
[ 'none', 'view' ],
[ 'deleted', 'none' ],
[ 'deleted', 'view-for-user' ],
[ 'deleted', 'view-public' ],
[ 'suppressed', 'none' ],
[ 'suppressed', 'view-for-user' ],
[ 'suppressed', 'view-public' ],
];
}
/**
* @dataProvider provideApiParamFormatting
* @covers \LogFormatter::formatParametersForApi
* @covers \LogFormatter::formatParameterValueForApi
*/
public function testApiParamFormatting( $key, $value, $expected ) {
$entry = $this->newLogEntry( 'param', [ $key => $value ] );
$formatter = $this->getServiceContainer()->getLogFormatterFactory()->newFromEntry( $entry );
$formatter->setContext( $this->context );
ApiResult::setIndexedTagName( $expected, 'param' );
ApiResult::setArrayType( $expected, 'assoc' );
$this->assertEquals( $expected, $formatter->formatParametersForApi() );
}
public static function provideApiParamFormatting() {
return [
[ 0, 'value', [ 'value' ] ],
[ 'named', 'value', [ 'named' => 'value' ] ],
[ '::key', 'value', [ 'key' => 'value' ] ],
[ '4::key', 'value', [ 'key' => 'value' ] ],
[ '4:raw:key', 'value', [ 'key' => 'value' ] ],
[ '4:plain:key', 'value', [ 'key' => 'value' ] ],
[ '4:bool:key', '1', [ 'key' => true ] ],
[ '4:bool:key', '0', [ 'key' => false ] ],
[ '4:number:key', '123', [ 'key' => 123 ] ],
[ '4:number:key', '123.5', [ 'key' => 123.5 ] ],
[ '4:array:key', [], [ 'key' => [ ApiResult::META_TYPE => 'array' ] ] ],
[ '4:assoc:key', [], [ 'key' => [ ApiResult::META_TYPE => 'assoc' ] ] ],
[ '4:kvp:key', [], [ 'key' => [ ApiResult::META_TYPE => 'kvp' ] ] ],
[ '4:timestamp:key', '20150102030405', [ 'key' => '2015-01-02T03:04:05Z' ] ],
[ '4:msg:key', 'parentheses', [
'key_key' => 'parentheses',
'key_text' => wfMessage( 'parentheses' )->text(),
] ],
[ '4:msg-content:key', 'parentheses', [
'key_key' => 'parentheses',
'key_text' => wfMessage( 'parentheses' )->inContentLanguage()->text(),
] ],
[ '4:title:key', 'project:foo', [
'key_ns' => NS_PROJECT,
'key_title' => Title::makeTitle( NS_PROJECT, 'Foo' )->getFullText(),
] ],
[ '4:title-link:key', 'project:foo', [
'key_ns' => NS_PROJECT,
'key_title' => Title::makeTitle( NS_PROJECT, 'Foo' )->getFullText(),
] ],
[ '4:title-link:key', '', [
'key_ns' => NS_SPECIAL,
'key_title' => SpecialPage::getTitleFor( 'Badtitle', '' )->getFullText(),
] ],
[ '4:user:key', 'foo', [ 'key' => 'Foo' ] ],
[ '4:user-link:key', 'foo', [ 'key' => 'Foo' ] ],
];
}
/**
* The testIrcMsgForAction* tests are supposed to cover the hacky
* LogFormatter::getIRCActionText / T36508
*
* Third parties bots listen to those messages. They are clever enough
* to fetch the i18n messages from the wiki and then analyze the IRC feed
* to reverse engineer the $1, $2 messages.
* One thing bots cannot detect is when MediaWiki change the meaning of
* a message like what happened when we deployed 1.19. $1 became the user
* performing the action which broke basically all bots around.
*
* Should cover the following log actions (which are most commonly used by bots):
* - block/block
* - block/unblock
* - block/reblock
* - delete/delete
* - delete/restore
* - newusers/create
* - newusers/create2
* - newusers/autocreate
* - move/move
* - move/move_redir
* - protect/protect
* - protect/modifyprotect
* - protect/unprotect
* - protect/move_prot
* - upload/upload
* - merge/merge
* - import/upload
* - import/interwiki
*
* As well as the following Auto Edit Summaries:
* - blank
* - replace
* - rollback
* - undo
*/
/**
* @covers \LogFormatter::getIRCActionComment
* @covers \LogFormatter::getIRCActionText
*/
public function testIrcMsgForLogTypeBlock() {
$sep = $this->context->msg( 'colon-separator' )->text();
# block/block
$this->assertIRCComment(
$this->context->msg( 'blocklogentry', 'SomeTitle', 'duration', '(flags)' )->plain()
. $sep . $this->user_comment,
'block', 'block',
[
'5::duration' => 'duration',
'6::flags' => 'flags',
],
$this->user_comment
);
# block/block - legacy
$this->assertIRCComment(
$this->context->msg( 'blocklogentry', 'SomeTitle', 'duration', '(flags)' )->plain()
. $sep . $this->user_comment,
'block', 'block',
[
'duration',
'flags',
],
$this->user_comment,
'',
true
);
# block/unblock
$this->assertIRCComment(
$this->context->msg( 'unblocklogentry', 'SomeTitle' )->plain() . $sep . $this->user_comment,
'block', 'unblock',
[],
$this->user_comment
);
# block/reblock
$this->assertIRCComment(
$this->context->msg( 'reblock-logentry', 'SomeTitle', 'duration', '(flags)' )->plain()
. $sep . $this->user_comment,
'block', 'reblock',
[
'5::duration' => 'duration',
'6::flags' => 'flags',
],
$this->user_comment
);
}
/**
* @covers \LogFormatter::getIRCActionComment
* @covers \LogFormatter::getIRCActionText
*/
public function testIrcMsgForLogTypeDelete() {
$sep = $this->context->msg( 'colon-separator' )->text();
# delete/delete
$this->assertIRCComment(
$this->context->msg( 'deletedarticle', 'SomeTitle' )->plain() . $sep . $this->user_comment,
'delete', 'delete',
[],
$this->user_comment
);
# delete/restore
$this->assertIRCComment(
$this->context->msg( 'undeletedarticle', 'SomeTitle' )->plain() . $sep . $this->user_comment,
'delete', 'restore',
[],
$this->user_comment
);
}
/**
* @covers \LogFormatter::getIRCActionComment
* @covers \LogFormatter::getIRCActionText
*/
public function testIrcMsgForLogTypeNewusers() {
$this->assertIRCComment(
'New user account',
'newusers', 'newusers',
[]
);
$this->assertIRCComment(
'New user account',
'newusers', 'create',
[]
);
$this->assertIRCComment(
'created new account SomeTitle',
'newusers', 'create2',
[]
);
$this->assertIRCComment(
'Account created automatically',
'newusers', 'autocreate',
[]
);
}
/**
* @covers \LogFormatter::getIRCActionComment
* @covers \LogFormatter::getIRCActionText
*/
public function testIrcMsgForLogTypeMove() {
$move_params = [
'4::target' => $this->target->getPrefixedText(),
'5::noredir' => 0,
];
$sep = $this->context->msg( 'colon-separator' )->text();
# move/move
$this->assertIRCComment(
$this->context->msg( '1movedto2', 'SomeTitle', 'TestTarget' )
->plain() . $sep . $this->user_comment,
'move', 'move',
$move_params,
$this->user_comment
);
# move/move_redir
$this->assertIRCComment(
$this->context->msg( '1movedto2_redir', 'SomeTitle', 'TestTarget' )
->plain() . $sep . $this->user_comment,
'move', 'move_redir',
$move_params,
$this->user_comment
);
}
/**
* @covers \LogFormatter::getIRCActionComment
* @covers \LogFormatter::getIRCActionText
*/
public function testIrcMsgForLogTypePatrol() {
# patrol/patrol
$this->assertIRCComment(
$this->context->msg( 'patrol-log-line', 'revision 777', '[[SomeTitle]]', '' )->plain(),
'patrol', 'patrol',
[
'4::curid' => '777',
'5::previd' => '666',
'6::auto' => 0,
]
);
}
/**
* @covers \LogFormatter::getIRCActionComment
* @covers \LogFormatter::getIRCActionText
*/
public function testIrcMsgForLogTypeProtect() {
$protectParams = [
'4::description' => '[edit=sysop] (indefinite) [move=sysop] (indefinite)'
];
$sep = $this->context->msg( 'colon-separator' )->text();
# protect/protect
$this->assertIRCComment(
$this->context->msg( 'protectedarticle', 'SomeTitle ' . $protectParams['4::description'] )
->plain() . $sep . $this->user_comment,
'protect', 'protect',
$protectParams,
$this->user_comment
);
# protect/unprotect
$this->assertIRCComment(
$this->context->msg( 'unprotectedarticle', 'SomeTitle' )->plain() . $sep . $this->user_comment,
'protect', 'unprotect',
[],
$this->user_comment
);
# protect/modify
$this->assertIRCComment(
$this->context->msg(
'modifiedarticleprotection',
'SomeTitle ' . $protectParams['4::description']
)->plain() . $sep . $this->user_comment,
'protect', 'modify',
$protectParams,
$this->user_comment
);
# protect/move_prot
$this->assertIRCComment(
$this->context->msg( 'movedarticleprotection', 'SomeTitle', 'OldTitle' )
->plain() . $sep . $this->user_comment,
'protect', 'move_prot',
[
'4::oldtitle' => 'OldTitle'
],
$this->user_comment
);
}
/**
* @covers \LogFormatter::getIRCActionComment
* @covers \LogFormatter::getIRCActionText
*/
public function testIrcMsgForLogTypeUpload() {
$sep = $this->context->msg( 'colon-separator' )->text();
# upload/upload
$this->assertIRCComment(
$this->context->msg( 'uploadedimage', 'SomeTitle' )->plain() . $sep . $this->user_comment,
'upload', 'upload',
[],
$this->user_comment
);
# upload/overwrite
$this->assertIRCComment(
$this->context->msg( 'overwroteimage', 'SomeTitle' )->plain() . $sep . $this->user_comment,
'upload', 'overwrite',
[],
$this->user_comment
);
}
/**
* @covers \LogFormatter::getIRCActionComment
* @covers \LogFormatter::getIRCActionText
*/
public function testIrcMsgForLogTypeMerge() {
$sep = $this->context->msg( 'colon-separator' )->text();
# merge/merge
$this->assertIRCComment(
$this->context->msg( 'pagemerge-logentry', 'SomeTitle', 'Dest', 'timestamp' )->plain()
. $sep . $this->user_comment,
'merge', 'merge',
[
'4::dest' => 'Dest',
'5::mergepoint' => 'timestamp',
],
$this->user_comment
);
}
/**
* @covers \LogFormatter::getIRCActionComment
* @covers \LogFormatter::getIRCActionText
*/
public function testIrcMsgForLogTypeImport() {
$sep = $this->context->msg( 'colon-separator' )->text();
# import/upload
$msg = $this->context->msg( 'import-logentry-upload', 'SomeTitle' )->plain() .
$sep .
$this->user_comment;
$this->assertIRCComment(
$msg,
'import', 'upload',
[],
$this->user_comment
);
# import/interwiki
$msg = $this->context->msg( 'import-logentry-interwiki', 'SomeTitle' )->plain() .
$sep .
$this->user_comment;
$this->assertIRCComment(
$msg,
'import', 'interwiki',
[],
$this->user_comment
);
}
/**
* @param string $expected Expected IRC text without colors codes
* @param string $type Log type (move, delete, suppress, patrol ...)
* @param string $action A log type action
* @param array $params
* @param string|null $comment A comment for the log action
* @param string $msg
* @param bool $legacy
*/
protected function assertIRCComment( $expected, $type, $action, $params,
$comment = null, $msg = '', $legacy = false
) {
$logEntry = new ManualLogEntry( $type, $action );
$logEntry->setPerformer( $this->user );
$logEntry->setTarget( $this->title );
if ( $comment !== null ) {
$logEntry->setComment( $comment );
}
$logEntry->setParameters( $params );
$logEntry->setLegacy( $legacy );
$formatter = $this->getServiceContainer()->getLogFormatterFactory()->newFromEntry( $logEntry );
$formatter->setContext( $this->context );
// Apply the same transformation as done in IRCColourfulRCFeedFormatter::getLine for rc_comment
$ircRcComment = IRCColourfulRCFeedFormatter::cleanupForIRC( $formatter->getIRCActionComment() );
$this->assertEquals(
$expected,
$ircRcComment,
$msg
);
}
}
PK ! Cy;2 2 logging/LogTests.i18n.phpnu Iw 'PHPUnit-log',
'log-description-phpunit' => 'Log for PHPUnit-tests',
'logentry-phpunit-test' => '$1 {{GENDER:$2|tests}} with page $3',
'logentry-phpunit-param' => '$4',
];
PK ! 2? 2? ! logging/BlockLogFormatterTest.phpnu Iw 'block',
'action' => 'block',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'5::duration' => 'infinity',
'6::flags' => 'anononly',
],
],
[
'text' => 'Sysop blocked Logtestuser with an expiration time of indefinite'
. ' (anonymous users only)',
'api' => [
'duration' => 'infinity',
'flags' => [ 'anononly' ],
],
'preload' => [ new TitleValue( NS_USER_TALK, 'Logtestuser' ) ],
],
],
// Old log format with one of the 4 values for 'infinity'
[
[
'type' => 'block',
'action' => 'block',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'5::duration' => 'infinite',
'6::flags' => 'anononly',
],
],
[
'text' => 'Sysop blocked Logtestuser with an expiration time of indefinite'
. ' (anonymous users only)',
'api' => [
'duration' => 'infinity',
'flags' => [ 'anononly' ],
],
'preload' => [ new TitleValue( NS_USER_TALK, 'Logtestuser' ) ],
],
],
// With blank page title (T224811)
[
[
'type' => 'block',
'action' => 'block',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => '',
'params' => [],
],
[
'text' => 'Sysop blocked (no username available) '
. 'with an expiration time of indefinite',
'api' => [
'duration' => 'infinity',
'flags' => [],
],
'preload' => [],
],
],
// Old legacy log
[
[
'type' => 'block',
'action' => 'block',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'infinite',
'anononly',
],
],
[
'legacy' => true,
'text' => 'Sysop blocked Logtestuser with an expiration time of indefinite'
. ' (anonymous users only)',
'api' => [
'duration' => 'infinity',
'flags' => [ 'anononly' ],
],
],
],
// Old legacy log without flag
[
[
'type' => 'block',
'action' => 'block',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'infinite',
],
],
[
'legacy' => true,
'text' => 'Sysop blocked Logtestuser with an expiration time of indefinite',
'api' => [
'duration' => 'infinity',
'flags' => [],
],
],
],
// Very old legacy log without duration
[
[
'type' => 'block',
'action' => 'block',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [],
],
[
'legacy' => true,
'text' => 'Sysop blocked Logtestuser with an expiration time of indefinite',
'api' => [
'duration' => 'infinity',
'flags' => [],
],
],
],
];
}
/**
* @dataProvider provideBlockLogDatabaseRows
*/
public function testBlockLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideReblockLogDatabaseRows() {
return [
// Current log format
[
[
'type' => 'block',
'action' => 'reblock',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'5::duration' => 'infinite',
'6::flags' => 'anononly',
],
],
[
'text' => 'Sysop changed block settings for Logtestuser with an expiration time of'
. ' indefinite (anonymous users only)',
'api' => [
'duration' => 'infinity',
'flags' => [ 'anononly' ],
],
],
],
// Old log
[
[
'type' => 'block',
'action' => 'reblock',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'infinite',
'anononly',
],
],
[
'legacy' => true,
'text' => 'Sysop changed block settings for Logtestuser with an expiration time of'
. ' indefinite (anonymous users only)',
'api' => [
'duration' => 'infinity',
'flags' => [ 'anononly' ],
],
],
],
// Older log without flag
[
[
'type' => 'block',
'action' => 'reblock',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'infinite',
]
],
[
'legacy' => true,
'text' => 'Sysop changed block settings for Logtestuser with an expiration time of indefinite',
'api' => [
'duration' => 'infinity',
'flags' => [],
],
],
],
];
}
/**
* @dataProvider provideReblockLogDatabaseRows
*/
public function testReblockLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideUnblockLogDatabaseRows() {
return [
// Current log format
[
[
'type' => 'block',
'action' => 'unblock',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [],
],
[
'text' => 'Sysop unblocked Logtestuser',
'api' => [],
],
],
];
}
/**
* @dataProvider provideUnblockLogDatabaseRows
*/
public function testUnblockLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideSuppressBlockLogDatabaseRows() {
return [
// Current log format
[
[
'type' => 'suppress',
'action' => 'block',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'5::duration' => 'infinite',
'6::flags' => 'anononly',
],
],
[
'text' => 'Sysop blocked Logtestuser with an expiration time of indefinite'
. ' (anonymous users only)',
'api' => [
'duration' => 'infinity',
'flags' => [ 'anononly' ],
],
],
],
// legacy log
[
[
'type' => 'suppress',
'action' => 'block',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'infinite',
'anononly',
],
],
[
'legacy' => true,
'text' => 'Sysop blocked Logtestuser with an expiration time of indefinite'
. ' (anonymous users only)',
'api' => [
'duration' => 'infinity',
'flags' => [ 'anononly' ],
],
],
],
];
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideSuppressBlockLogDatabaseRowsNonPrivileged() {
return [
// Current log format
[
[
'type' => 'suppress',
'action' => 'block',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'5::duration' => 'infinite',
'6::flags' => 'anononly',
],
],
[
'text' => '(username removed) (log details removed)',
'api' => [
'duration' => 'infinity',
'flags' => [ 'anononly' ],
],
],
],
// legacy log
[
[
'type' => 'suppress',
'action' => 'block',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'infinite',
'anononly',
],
],
[
'legacy' => true,
'text' => '(username removed) (log details removed)',
'api' => [
'duration' => 'infinity',
'flags' => [ 'anononly' ],
],
],
],
];
}
/**
* @dataProvider provideSuppressBlockLogDatabaseRowsNonPrivileged
*/
public function testSuppressBlockLogDatabaseRowsNonPrivileged( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideSuppressReblockLogDatabaseRows() {
return [
// Current log format
[
[
'type' => 'suppress',
'action' => 'reblock',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'5::duration' => 'infinite',
'6::flags' => 'anononly',
],
],
[
'text' => 'Sysop changed block settings for Logtestuser with an expiration time of'
. ' indefinite (anonymous users only)',
'api' => [
'duration' => 'infinity',
'flags' => [ 'anononly' ],
],
],
],
// Legacy format
[
[
'type' => 'suppress',
'action' => 'reblock',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'infinite',
'anononly',
],
],
[
'legacy' => true,
'text' => 'Sysop changed block settings for Logtestuser with an expiration time of'
. ' indefinite (anonymous users only)',
'api' => [
'duration' => 'infinity',
'flags' => [ 'anononly' ],
],
],
],
];
}
/**
* @dataProvider provideSuppressBlockLogDatabaseRows
* @dataProvider provideSuppressReblockLogDatabaseRows
*/
public function testSuppressBlockLogDatabaseRows( $row, $extra ) {
$this->setGroupPermissions(
[
'oversight' => [
'viewsuppressed' => true,
'suppressionlog' => true,
],
]
);
$this->doTestLogFormatter( $row, $extra, [ 'oversight' ] );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideSuppressReblockLogDatabaseRowsNonPrivileged() {
return [
// Current log format
[
[
'type' => 'suppress',
'action' => 'reblock',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'5::duration' => 'infinite',
'6::flags' => 'anononly',
],
],
[
'text' => '(username removed) (log details removed)',
'api' => [
'duration' => 'infinity',
'flags' => [ 'anononly' ],
],
],
],
// Legacy format
[
[
'type' => 'suppress',
'action' => 'reblock',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'infinite',
'anononly',
],
],
[
'legacy' => true,
'text' => '(username removed) (log details removed)',
'api' => [
'duration' => 'infinity',
'flags' => [ 'anononly' ],
],
],
],
];
}
/**
* @dataProvider provideSuppressReblockLogDatabaseRowsNonPrivileged
*/
public function testSuppressReblockLogDatabaseRowsNonPrivileged( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
public static function providePartialBlockLogDatabaseRows() {
return [
[
[
'type' => 'block',
'action' => 'block',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'5::duration' => 'infinite',
'6::flags' => 'anononly',
'7::restrictions' => [ 'pages' => [ 'User:Test1', 'Main Page' ] ],
'sitewide' => false,
],
],
[
'text' => 'Sysop blocked Logtestuser from the pages User:Test1 and Main Page'
. ' with an expiration time of indefinite (anonymous users only)',
'api' => [
'duration' => 'infinity',
'flags' => [ 'anononly' ],
'restrictions' => [
'pages' => [
[
'page_ns' => 2,
'page_title' => 'User:Test1',
], [
'page_ns' => 0,
'page_title' => 'Main Page',
],
],
],
'sitewide' => false,
],
],
],
[
[
'type' => 'block',
'action' => 'block',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'5::duration' => 'infinite',
'6::flags' => 'anononly',
'7::restrictions' => [
'namespaces' => [ NS_USER ],
],
'sitewide' => false,
],
],
[
'text' => 'Sysop blocked Logtestuser from the namespace User'
. ' with an expiration time of indefinite (anonymous users only)',
'api' => [
'duration' => 'infinity',
'flags' => [ 'anononly' ],
'restrictions' => [
'namespaces' => [ NS_USER ],
],
'sitewide' => false,
],
],
],
[
[
'type' => 'block',
'action' => 'block',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'5::duration' => 'infinite',
'6::flags' => 'anononly',
'7::restrictions' => [
'pages' => [ 'Main Page' ],
'namespaces' => [ NS_USER, NS_MAIN ],
],
'sitewide' => false,
],
],
[
'text' => 'Sysop blocked Logtestuser from the page Main Page and the'
. ' namespaces User and (Main) with an expiration time of indefinite'
. ' (anonymous users only)',
'api' => [
'duration' => 'infinity',
'flags' => [ 'anononly' ],
'restrictions' => [
'pages' => [
[
'page_ns' => 0,
'page_title' => 'Main Page',
],
],
'namespaces' => [ NS_USER, NS_MAIN ],
],
'sitewide' => false,
],
],
],
[
[
'type' => 'block',
'action' => 'block',
'comment' => 'Block comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'Logtestuser',
'params' => [
'5::duration' => 'infinite',
'6::flags' => 'anononly',
'sitewide' => false,
],
],
[
'text' => 'Sysop blocked Logtestuser from specified non-editing actions'
. ' with an expiration time of indefinite (anonymous users only)',
'api' => [
'duration' => 'infinity',
'flags' => [ 'anononly' ],
'sitewide' => false,
],
],
],
];
}
/**
* @dataProvider providePartialBlockLogDatabaseRows
*/
public function testPartialBlockLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
}
PK ! V-" $ logging/NewUsersLogFormatterTest.phpnu Iw mergeMwGlobalArrayValue( 'wgLogActionsHandlers', [
'newusers/newusers' => NewUsersLogFormatter::class,
'newusers/create' => NewUsersLogFormatter::class,
'newusers/create2' => NewUsersLogFormatter::class,
'newusers/byemail' => NewUsersLogFormatter::class,
'newusers/autocreate' => NewUsersLogFormatter::class,
] );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideNewUsersLogDatabaseRows() {
return [
// Only old logs
[
[
'type' => 'newusers',
'action' => 'newusers',
'comment' => 'newusers comment',
'user' => 0,
'user_text' => 'New user',
'namespace' => NS_USER,
'title' => 'New user',
'params' => [],
],
[
'legacy' => true,
'text' => 'User account New user was created',
'api' => [],
],
],
];
}
/**
* @dataProvider provideNewUsersLogDatabaseRows
*/
public function testNewUsersLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideCreateLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'newusers',
'action' => 'create',
'comment' => 'newusers comment',
'user' => 0,
'user_text' => 'New user',
'namespace' => NS_USER,
'title' => 'New user',
'params' => [
'4::userid' => 1,
],
],
[
'text' => 'User account New user was created',
'api' => [
'userid' => 1,
],
],
],
];
}
/**
* @dataProvider provideCreateLogDatabaseRows
*/
public function testCreateLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideCreate2LogDatabaseRows() {
return [
// Current format
[
[
'type' => 'newusers',
'action' => 'create2',
'comment' => 'newusers comment',
'user' => 0,
'user_text' => 'User',
'namespace' => NS_USER,
'title' => 'UTSysop'
],
[
'text' => 'User account UTSysop was created by User'
],
],
];
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideByemailLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'newusers',
'action' => 'byemail',
'comment' => 'newusers comment',
'user' => 0,
'user_text' => 'Sysop',
'namespace' => NS_USER,
'title' => 'UTSysop'
],
[
'text' => 'User account UTSysop was created by Sysop and password was sent by email'
],
],
];
}
/**
* @dataProvider provideCreate2LogDatabaseRows
* @dataProvider provideByemailLogDatabaseRows
*/
public function testCreate2LogDatabaseRows( $row, $extra ) {
// Make UTSysop user and use its user_id (sequence does not reset to 1 for postgres)
$user = static::getTestSysop()->getUser();
$row['params']['4::userid'] = $user->getId();
$extra['api']['userid'] = $user->getId();
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideAutocreateLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'newusers',
'action' => 'autocreate',
'comment' => 'newusers comment',
'user' => 0,
'user_text' => 'New user',
'namespace' => NS_USER,
'title' => 'New user',
'params' => [
'4::userid' => 1,
],
],
[
'text' => 'User account New user was created automatically',
'api' => [
'userid' => 1,
],
],
],
];
}
/**
* @dataProvider provideAutocreateLogDatabaseRows
*/
public function testAutocreateLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
}
PK ! h%Ax x ( logging/ContentModelLogFormatterTest.phpnu Iw 'contentmodel',
'action' => 'new',
'comment' => 'new content model comment',
'namespace' => NS_MAIN,
'title' => 'ContentModelPage',
'params' => [
'5::newModel' => 'testcontentmodel',
],
],
[
'text' => 'User created the page ContentModelPage ' .
'using a non-default content model ' .
'"testcontentmodel"',
'api' => [
'newModel' => 'testcontentmodel',
],
],
],
[
[
'type' => 'contentmodel',
'action' => 'change',
'comment' => 'change content model comment',
'namespace' => NS_MAIN,
'title' => 'ContentModelPage',
'params' => [
'4::oldmodel' => 'wikitext',
'5::newModel' => 'testcontentmodel',
],
],
[
'text' => 'User changed the content model of the page ' .
'ContentModelPage from "wikitext" to ' .
'"testcontentmodel"',
'api' => [
'oldmodel' => 'wikitext',
'newModel' => 'testcontentmodel',
],
],
],
];
}
/**
* @dataProvider provideContentModelLogDatabaseRows
*/
public function testContentModelLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
}
PK ! Z $ logging/PageLangLogFormatterTest.phpnu Iw clearHooks();
// Register LogHandler, see $wgPageLanguageUseDB in Setup.php
$this->overrideConfigValue(
MainConfigNames::LogActionsHandlers,
MainConfigSchema::getDefaultValue( MainConfigNames::LogActionsHandlers ) +
[
'pagelang/pagelang' => [
'class' => PageLangLogFormatter::class,
'services' => [
'LanguageNameUtils',
]
]
]
);
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function providePageLangLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'pagelang',
'action' => 'pagelang',
'comment' => 'page lang comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'4::oldlanguage' => 'en',
'5::newlanguage' => 'de[def]',
],
],
[
'text' => 'User changed the language of Page from English (en) to Deutsch (de) [default]',
'api' => [
'oldlanguage' => 'en',
'newlanguage' => 'de[def]'
],
],
],
];
}
/**
* @dataProvider providePageLangLogDatabaseRows
*/
public function testPageLangLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
}
PK ! p
" logging/ImportLogFormatterTest.phpnu Iw 'import',
'action' => 'upload',
'comment' => 'upload comment',
'namespace' => NS_MAIN,
'title' => 'ImportPage',
'params' => [
'4:number:count' => '1',
],
],
[
'text' => 'User imported ImportPage by file upload (1 revision)',
'api' => [
'count' => 1,
],
],
],
// old format - without details
[
[
'type' => 'import',
'action' => 'upload',
'comment' => '1 revision: import comment',
'namespace' => NS_MAIN,
'title' => 'ImportPage',
'params' => [],
],
[
'text' => 'User imported ImportPage by file upload',
'api' => [],
],
],
];
}
/**
* @dataProvider provideUploadLogDatabaseRows
*/
public function testUploadLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideInterwikiLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'import',
'action' => 'interwiki',
'comment' => 'interwiki comment',
'namespace' => NS_MAIN,
'title' => 'ImportPage',
'params' => [
'4:number:count' => '1',
'5:title-link:interwiki' => 'importiw:PageImport',
],
],
[
'text' => 'User imported ImportPage from importiw:PageImport (1 revision)',
'api' => [
'count' => 1,
'interwiki_ns' => 0,
'interwiki_title' => 'importiw:PageImport',
],
],
],
// old format - without details
[
[
'type' => 'import',
'action' => 'interwiki',
'comment' => '1 revision from importiw:PageImport: interwiki comment',
'namespace' => NS_MAIN,
'title' => 'ImportPage',
'params' => [],
],
[
'text' => 'User imported ImportPage from another wiki',
'api' => [],
],
],
];
}
/**
* @dataProvider provideInterwikiLogDatabaseRows
*/
public function testInterwikiLogDatabaseRows( $row, $extra ) {
// Setup importiw: as interwiki prefix
$interwikiLookup = $this->getDummyInterwikiLookup( [ 'importiw' ] );
$this->setService( 'InterwikiLookup', $interwikiLookup );
$this->doTestLogFormatter( $row, $extra );
}
}
PK ! O8 logging/MoveLogFormatterTest.phpnu Iw 'move',
'action' => 'move',
'comment' => 'move comment with redirect',
'namespace' => NS_MAIN,
'title' => 'OldPage',
'params' => [
'4::target' => 'NewPage',
'5::noredir' => '0',
],
],
[
'text' => 'User moved page OldPage to NewPage',
'api' => [
'target_ns' => 0,
'target_title' => 'NewPage',
'suppressredirect' => false,
],
],
],
// Current format - without redirect
[
[
'type' => 'move',
'action' => 'move',
'comment' => 'move comment',
'namespace' => NS_MAIN,
'title' => 'OldPage',
'params' => [
'4::target' => 'NewPage',
'5::noredir' => '1',
],
],
[
'text' => 'User moved page OldPage to NewPage without leaving a redirect',
'api' => [
'target_ns' => 0,
'target_title' => 'NewPage',
'suppressredirect' => true,
],
],
],
// legacy format - with redirect
[
[
'type' => 'move',
'action' => 'move',
'comment' => 'move comment',
'namespace' => NS_MAIN,
'title' => 'OldPage',
'params' => [
'NewPage',
'',
],
],
[
'legacy' => true,
'text' => 'User moved page OldPage to NewPage',
'api' => [
'target_ns' => 0,
'target_title' => 'NewPage',
'suppressredirect' => false,
],
],
],
// legacy format - without redirect
[
[
'type' => 'move',
'action' => 'move',
'comment' => 'move comment',
'namespace' => NS_MAIN,
'title' => 'OldPage',
'params' => [
'NewPage',
'1',
],
],
[
'legacy' => true,
'text' => 'User moved page OldPage to NewPage without leaving a redirect',
'api' => [
'target_ns' => 0,
'target_title' => 'NewPage',
'suppressredirect' => true,
],
],
],
// old format without flag for redirect suppression
[
[
'type' => 'move',
'action' => 'move',
'comment' => 'move comment',
'namespace' => NS_MAIN,
'title' => 'OldPage',
'params' => [
'NewPage',
],
],
[
'legacy' => true,
'text' => 'User moved page OldPage to NewPage',
'api' => [
'target_ns' => 0,
'target_title' => 'NewPage',
'suppressredirect' => false,
],
],
],
// row with invalid title (T370396)
[
[
'type' => 'move',
'action' => 'move',
'comment' => 'comment',
'namespace' => NS_TALK,
'title' => 'OldPage',
'params' => [
'4::target' => 'Talk:Help:NewPage',
'5::noredir' => '0',
],
],
[
'text' => 'User moved page Talk:OldPage to Invalid title',
'api' => [
'target_ns' => -1,
'target_title' => 'Special:Badtitle/Talk:Help:NewPage',
'suppressredirect' => false,
],
'preload' => [ /* empty, do not try to preload the bad title */ ],
],
],
];
}
/**
* @dataProvider provideMoveLogDatabaseRows
*/
public function testMoveLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideMoveRedirLogDatabaseRows() {
return [
// Current format - with redirect
[
[
'type' => 'move',
'action' => 'move_redir',
'comment' => 'move comment with redirect',
'namespace' => NS_MAIN,
'title' => 'OldPage',
'params' => [
'4::target' => 'NewPage',
'5::noredir' => '0',
],
],
[
'text' => 'User moved page OldPage to NewPage over redirect',
'api' => [
'target_ns' => 0,
'target_title' => 'NewPage',
'suppressredirect' => false,
],
],
],
// Current format - without redirect
[
[
'type' => 'move',
'action' => 'move_redir',
'comment' => 'move comment',
'namespace' => NS_MAIN,
'title' => 'OldPage',
'params' => [
'4::target' => 'NewPage',
'5::noredir' => '1',
],
],
[
'text' => 'User moved page OldPage to NewPage over a redirect without leaving a redirect',
'api' => [
'target_ns' => 0,
'target_title' => 'NewPage',
'suppressredirect' => true,
],
],
],
// legacy format - with redirect
[
[
'type' => 'move',
'action' => 'move_redir',
'comment' => 'move comment',
'namespace' => NS_MAIN,
'title' => 'OldPage',
'params' => [
'NewPage',
'',
],
],
[
'legacy' => true,
'text' => 'User moved page OldPage to NewPage over redirect',
'api' => [
'target_ns' => 0,
'target_title' => 'NewPage',
'suppressredirect' => false,
],
],
],
// legacy format - without redirect
[
[
'type' => 'move',
'action' => 'move_redir',
'comment' => 'move comment',
'namespace' => NS_MAIN,
'title' => 'OldPage',
'params' => [
'NewPage',
'1',
],
],
[
'legacy' => true,
'text' => 'User moved page OldPage to NewPage over a redirect without leaving a redirect',
'api' => [
'target_ns' => 0,
'target_title' => 'NewPage',
'suppressredirect' => true,
],
],
],
// old format without flag for redirect suppression
[
[
'type' => 'move',
'action' => 'move_redir',
'comment' => 'move comment',
'namespace' => NS_MAIN,
'title' => 'OldPage',
'params' => [
'NewPage',
],
],
[
'legacy' => true,
'text' => 'User moved page OldPage to NewPage over redirect',
'api' => [
'target_ns' => 0,
'target_title' => 'NewPage',
'suppressredirect' => false,
],
],
],
];
}
/**
* @dataProvider provideMoveRedirLogDatabaseRows
*/
public function testMoveRedirLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
}
PK ! 5( logging/DatabaseLogEntryTest.phpnu Iw createMock( IReadableDatabase::class );
$db->expects( self::once() )
->method( 'selectRow' )
->with( $selectFields['tables'],
$selectFields['fields'],
$selectFields['conds'],
'DatabaseLogEntry::newFromId',
$selectFields['options'],
$selectFields['join_conds']
)
->will( self::returnValue( $row ) );
/** @var IReadableDatabase $db */
$logEntry = DatabaseLogEntry::newFromId( $id, $db );
if ( !$expectedFields ) {
self::assertNull( $logEntry, "Expected no log entry returned for id=$id" );
} else {
self::assertEquals( $id, $logEntry->getId() );
self::assertEquals( $expectedFields['type'], $logEntry->getType() );
self::assertEquals( $expectedFields['comment'], $logEntry->getComment() );
}
}
public static function provideNewFromId() {
$newTables = [
'tables' => [
'logging',
'comment_log_comment' => 'comment',
'logging_actor' => 'actor',
'user' => 'user',
],
'fields' => [
'log_id',
'log_type',
'log_action',
'log_timestamp',
'log_namespace',
'log_title',
'log_params',
'log_deleted',
'user_id',
'user_name',
'log_comment_text' => 'comment_log_comment.comment_text',
'log_comment_data' => 'comment_log_comment.comment_data',
'log_comment_cid' => 'comment_log_comment.comment_id',
'log_user' => 'logging_actor.actor_user',
'log_user_text' => 'logging_actor.actor_name',
'log_actor',
],
'options' => [],
'join_conds' => [
'user' => [ 'LEFT JOIN', 'user_id=logging_actor.actor_user' ],
'comment_log_comment' => [ 'JOIN', 'comment_log_comment.comment_id = log_comment_id' ],
'logging_actor' => [ 'JOIN', 'actor_id=log_actor' ],
],
];
return [
[
0,
$newTables + [ 'conds' => [ 'log_id' => 0 ] ],
null,
null
],
[
123,
$newTables + [ 'conds' => [ 'log_id' => 123 ] ],
[
'log_id' => 123,
'log_type' => 'foobarize',
'log_comment_text' => 'test!',
'log_comment_data' => null,
],
[ 'type' => 'foobarize', 'comment' => 'test!' ]
],
[
567,
$newTables + [ 'conds' => [ 'log_id' => 567 ] ],
[
'log_id' => 567,
'log_type' => 'foobarize',
'log_comment_text' => 'test!',
'log_comment_data' => null,
],
[ 'type' => 'foobarize', 'comment' => 'test!' ]
],
];
}
public static function provideGetPerformerIdentity() {
yield 'registered actor' => [
'actor_row_fields' => [
'user_id' => 42,
'log_user_text' => 'Testing',
'log_actor' => 24,
],
UserIdentityValue::newRegistered( 42, 'Testing' ),
];
yield 'anon actor' => [
'actor_row_fields' => [
'log_user_text' => '127.0.0.1',
'log_actor' => 24,
],
UserIdentityValue::newAnonymous( '127.0.0.1' ),
];
yield 'unknown actor' => [
'actor_row_fields' => [],
new UserIdentityValue( 0, ActorStore::UNKNOWN_USER_NAME ),
];
}
/**
* @dataProvider provideGetPerformerIdentity
* @covers \DatabaseLogEntry::getPerformerIdentity
*/
public function testGetPerformer( array $actorRowFields, UserIdentity $expected ) {
$logEntry = DatabaseLogEntry::newFromRow( [
'log_id' => 1,
] + $actorRowFields );
$performer = $logEntry->getPerformerIdentity();
$this->assertTrue( $expected->equals( $performer ) );
}
}
PK ! Y(1 1 # logging/ProtectLogFormatterTest.phpnu Iw createNoOpMock( IDatabase::class, [ 'getInfinity' ] );
$db->method( 'getInfinity' )->willReturn( 'infinity' );
$lbFactory = $this->createMock( LBFactory::class );
$lbFactory->method( 'getReplicaDatabase' )->willReturn( $db );
$this->setService( 'DBLoadBalancerFactory', $lbFactory );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideProtectLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'protect',
'action' => 'protect',
'comment' => 'protect comment',
'namespace' => NS_MAIN,
'title' => 'ProtectPage',
'params' => [
'4::description' => '[edit=sysop] (indefinite)[move=sysop] (indefinite)',
'5:bool:cascade' => false,
'details' => [
[
'type' => 'edit',
'level' => 'sysop',
'expiry' => 'infinity',
'cascade' => false,
],
[
'type' => 'move',
'level' => 'sysop',
'expiry' => 'infinity',
'cascade' => false,
],
],
],
],
[
'text' => 'User protected ProtectPage [Edit=Allow only administrators] ' .
'(indefinite) [Move=Allow only administrators] (indefinite)',
'api' => [
'description' => '[edit=sysop] (indefinite)[move=sysop] (indefinite)',
'cascade' => false,
'details' => [
[
'type' => 'edit',
'level' => 'sysop',
'expiry' => 'infinite',
'cascade' => false,
],
[
'type' => 'move',
'level' => 'sysop',
'expiry' => 'infinite',
'cascade' => false,
],
],
],
],
],
// Current format with cascade
[
[
'type' => 'protect',
'action' => 'protect',
'comment' => 'protect comment',
'namespace' => NS_MAIN,
'title' => 'ProtectPage',
'params' => [
'4::description' => '[edit=sysop] (indefinite)[move=sysop] (indefinite)',
'5:bool:cascade' => true,
'details' => [
[
'type' => 'edit',
'level' => 'sysop',
'expiry' => 'infinity',
'cascade' => true,
],
[
'type' => 'move',
'level' => 'sysop',
'expiry' => 'infinity',
'cascade' => false,
],
],
],
],
[
'text' => 'User protected ProtectPage [Edit=Allow only administrators] ' .
'(indefinite) [Move=Allow only administrators] (indefinite) [cascading]',
'api' => [
'description' => '[edit=sysop] (indefinite)[move=sysop] (indefinite)',
'cascade' => true,
'details' => [
[
'type' => 'edit',
'level' => 'sysop',
'expiry' => 'infinite',
'cascade' => true,
],
[
'type' => 'move',
'level' => 'sysop',
'expiry' => 'infinite',
'cascade' => false,
],
],
],
],
],
// Legacy format
[
[
'type' => 'protect',
'action' => 'protect',
'comment' => 'protect comment',
'namespace' => NS_MAIN,
'title' => 'ProtectPage',
'params' => [
'[edit=sysop] (indefinite)[move=sysop] (indefinite)',
'',
],
],
[
'legacy' => true,
'text' => 'User protected ProtectPage [edit=sysop] (indefinite)[move=sysop] (indefinite)',
'api' => [
'description' => '[edit=sysop] (indefinite)[move=sysop] (indefinite)',
'cascade' => false,
],
],
],
// Legacy format with cascade
[
[
'type' => 'protect',
'action' => 'protect',
'comment' => 'protect comment',
'namespace' => NS_MAIN,
'title' => 'ProtectPage',
'params' => [
'[edit=sysop] (indefinite)[move=sysop] (indefinite)',
'cascade',
],
],
[
'legacy' => true,
'text' => 'User protected ProtectPage [edit=sysop] ' .
'(indefinite)[move=sysop] (indefinite) [cascading]',
'api' => [
'description' => '[edit=sysop] (indefinite)[move=sysop] (indefinite)',
'cascade' => true,
],
],
],
];
}
/**
* @dataProvider provideProtectLogDatabaseRows
*/
public function testProtectLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideModifyLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'protect',
'action' => 'modify',
'comment' => 'protect comment',
'namespace' => NS_MAIN,
'title' => 'ProtectPage',
'params' => [
'4::description' => '[edit=sysop] (indefinite)[move=sysop] (indefinite)',
'5:bool:cascade' => false,
'details' => [
[
'type' => 'edit',
'level' => 'sysop',
'expiry' => 'infinity',
'cascade' => false,
],
[
'type' => 'move',
'level' => 'sysop',
'expiry' => 'infinity',
'cascade' => false,
],
],
],
],
[
'text' => 'User changed protection settings for ProtectPage ' .
'[Edit=Allow only administrators] ' .
'(indefinite) [Move=Allow only administrators] (indefinite)',
'api' => [
'description' => '[edit=sysop] (indefinite)[move=sysop] (indefinite)',
'cascade' => false,
'details' => [
[
'type' => 'edit',
'level' => 'sysop',
'expiry' => 'infinite',
'cascade' => false,
],
[
'type' => 'move',
'level' => 'sysop',
'expiry' => 'infinite',
'cascade' => false,
],
],
],
],
],
// Current format with cascade
[
[
'type' => 'protect',
'action' => 'modify',
'comment' => 'protect comment',
'namespace' => NS_MAIN,
'title' => 'ProtectPage',
'params' => [
'4::description' => '[edit=sysop] (indefinite)[move=sysop] (indefinite)',
'5:bool:cascade' => true,
'details' => [
[
'type' => 'edit',
'level' => 'sysop',
'expiry' => 'infinity',
'cascade' => true,
],
[
'type' => 'move',
'level' => 'sysop',
'expiry' => 'infinity',
'cascade' => false,
],
],
],
],
[
'text' => 'User changed protection settings for ProtectPage ' .
'[Edit=Allow only administrators] (indefinite) ' .
'[Move=Allow only administrators] (indefinite) [cascading]',
'api' => [
'description' => '[edit=sysop] (indefinite)[move=sysop] (indefinite)',
'cascade' => true,
'details' => [
[
'type' => 'edit',
'level' => 'sysop',
'expiry' => 'infinite',
'cascade' => true,
],
[
'type' => 'move',
'level' => 'sysop',
'expiry' => 'infinite',
'cascade' => false,
],
],
],
],
],
// Legacy format
[
[
'type' => 'protect',
'action' => 'modify',
'comment' => 'protect comment',
'namespace' => NS_MAIN,
'title' => 'ProtectPage',
'params' => [
'[edit=sysop] (indefinite)[move=sysop] (indefinite)',
'',
],
],
[
'legacy' => true,
'text' => 'User changed protection settings for ProtectPage ' .
'[edit=sysop] (indefinite)[move=sysop] (indefinite)',
'api' => [
'description' => '[edit=sysop] (indefinite)[move=sysop] (indefinite)',
'cascade' => false,
],
],
],
// Legacy format with cascade
[
[
'type' => 'protect',
'action' => 'modify',
'comment' => 'protect comment',
'namespace' => NS_MAIN,
'title' => 'ProtectPage',
'params' => [
'[edit=sysop] (indefinite)[move=sysop] (indefinite)',
'cascade',
],
],
[
'legacy' => true,
'text' => 'User changed protection settings for ProtectPage ' .
'[edit=sysop] (indefinite)[move=sysop] (indefinite) [cascading]',
'api' => [
'description' => '[edit=sysop] (indefinite)[move=sysop] (indefinite)',
'cascade' => true,
],
],
],
];
}
/**
* @dataProvider provideModifyLogDatabaseRows
*/
public function testModifyLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideUnprotectLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'protect',
'action' => 'unprotect',
'comment' => 'unprotect comment',
'namespace' => NS_MAIN,
'title' => 'ProtectPage',
'params' => [],
],
[
'text' => 'User removed protection from ProtectPage',
'api' => [],
],
],
];
}
/**
* @dataProvider provideUnprotectLogDatabaseRows
*/
public function testUnprotectLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
/**
* Provide different rows from the logging table to test
* for backward compatibility.
* Do not change the existing data, just add a new database row
*/
public static function provideMoveProtLogDatabaseRows() {
return [
// Current format
[
[
'type' => 'protect',
'action' => 'move_prot',
'comment' => 'Move comment',
'namespace' => NS_MAIN,
'title' => 'NewPage',
'params' => [
'4::oldtitle' => 'OldPage',
],
],
[
'text' => 'User moved protection settings from OldPage to NewPage',
'api' => [
'oldtitle_ns' => 0,
'oldtitle_title' => 'OldPage',
],
],
],
// Legacy format
[
[
'type' => 'protect',
'action' => 'move_prot',
'comment' => 'Move comment',
'namespace' => NS_MAIN,
'title' => 'NewPage',
'params' => [
'OldPage',
],
],
[
'legacy' => true,
'text' => 'User moved protection settings from OldPage to NewPage',
'api' => [
'oldtitle_ns' => 0,
'oldtitle_title' => 'OldPage',
],
],
],
];
}
/**
* @dataProvider provideMoveProtLogDatabaseRows
*/
public function testMoveProtLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
public static function provideGetActionLinks() {
yield [
[ 'protect' ],
true
];
yield [
[],
false
];
}
/**
* @param string[] $permissions
* @param bool $shouldMatch
* @dataProvider provideGetActionLinks
* @covers \ProtectLogFormatter::getActionLinks
*/
public function testGetActionLinks( array $permissions, $shouldMatch ) {
RequestContext::resetMain();
$user = $this->mockUserAuthorityWithPermissions( new UserIdentityValue( 42, __METHOD__ ), $permissions );
$row = $this->expandDatabaseRow( [
'type' => 'protect',
'action' => 'unprotect',
'comment' => 'unprotect comment',
'namespace' => NS_MAIN,
'title' => 'ProtectPage',
'params' => [],
], false );
$context = new RequestContext();
$context->setAuthority( $user );
$context->setLanguage( 'en' );
$formatter = $this->getServiceContainer()->getLogFormatterFactory()->newFromRow( $row );
$formatter->setContext( $context );
$titleFactory = $this->createMock( TitleFactory::class );
$titleFactory->method( 'makeTitle' )->willReturnCallback( static function ( ...$params ) {
$ret = Title::makeTitle( ...$params );
$ret->resetArticleID( 0 );
return $ret;
} );
$this->setService( 'TitleFactory', $titleFactory );
$formatter->setLinkRenderer( ( new LinkRendererFactory(
$this->getServiceContainer()->getTitleFormatter(),
$this->createMock( LinkCache::class ),
$this->getServiceContainer()->getSpecialPageFactory(),
$this->getServiceContainer()->getHookContainer()
) )->create() );
if ( $shouldMatch ) {
$this->assertStringMatchesFormat(
'%Aaction=protect%A', $formatter->getActionLinks() );
} else {
$this->assertStringNotMatchesFormat(
'%Aaction=protect%A', $formatter->getActionLinks() );
}
}
}
PK ! }U U ! logging/MergeLogFormatterTest.phpnu Iw 'merge',
'action' => 'merge',
'comment' => 'Merge comment',
'namespace' => NS_MAIN,
'title' => 'OldPage',
'params' => [
'4::dest' => 'NewPage',
'5::mergepoint' => '20140804160710',
'6::mergerevid' => '1234'
],
],
[
'text' => 'User merged OldPage into NewPage (revisions up to 16:07, 4 August 2014)',
'api' => [
'mergerevid' => '1234',
'dest_ns' => 0,
'dest_title' => 'NewPage',
'mergepoint' => '2014-08-04T16:07:10Z',
],
],
],
// Same format without a revid
[
[
'type' => 'merge',
'action' => 'merge',
'comment' => 'Merge comment',
'namespace' => NS_MAIN,
'title' => 'OldPage',
'params' => [
'4::dest' => 'NewPage',
'5::mergepoint' => '20140804160710',
],
],
[
'text' => 'User merged OldPage into NewPage (revisions up to 16:07, 4 August 2014)',
'api' => [
'dest_ns' => 0,
'dest_title' => 'NewPage',
'mergepoint' => '2014-08-04T16:07:10Z',
],
],
],
// Legacy format
[
[
'type' => 'merge',
'action' => 'merge',
'comment' => 'merge comment',
'namespace' => NS_MAIN,
'title' => 'OldPage',
'params' => [
'NewPage',
'20140804160710',
],
],
[
'legacy' => true,
'text' => 'User merged OldPage into NewPage (revisions up to 16:07, 4 August 2014)',
'api' => [
'dest_ns' => 0,
'dest_title' => 'NewPage',
'mergepoint' => '2014-08-04T16:07:10Z',
],
],
],
];
}
/**
* @dataProvider provideMergeLogDatabaseRows
*/
public function testMergeLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
}
PK ! 4kW " logging/PatrolLogFormatterTest.phpnu Iw 'patrol',
'action' => 'patrol',
'comment' => 'patrol comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'4::curid' => 2,
'5::previd' => 1,
'6::auto' => 0,
],
],
[
'text' => 'User marked revision 2 of page Page patrolled',
'api' => [
'curid' => 2,
'previd' => 1,
'auto' => false,
],
],
],
// Current format - autopatrol
[
[
'type' => 'patrol',
'action' => 'patrol',
'comment' => 'patrol comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'4::curid' => 2,
'5::previd' => 1,
'6::auto' => 1,
],
],
[
'text' => 'User automatically marked revision 2 of page Page patrolled',
'api' => [
'curid' => 2,
'previd' => 1,
'auto' => true,
],
],
],
// Legacy format
[
[
'type' => 'patrol',
'action' => 'patrol',
'comment' => 'patrol comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'2',
'1',
'0',
],
],
[
'legacy' => true,
'text' => 'User marked revision 2 of page Page patrolled',
'api' => [
'curid' => 2,
'previd' => 1,
'auto' => false,
],
],
],
// Legacy format - autopatrol
[
[
'type' => 'patrol',
'action' => 'patrol',
'comment' => 'patrol comment',
'namespace' => NS_MAIN,
'title' => 'Page',
'params' => [
'2',
'1',
'1',
],
],
[
'legacy' => true,
'text' => 'User automatically marked revision 2 of page Page patrolled',
'api' => [
'curid' => 2,
'previd' => 1,
'auto' => true,
],
],
],
];
}
/**
* @dataProvider providePatrolLogDatabaseRows
*/
public function testPatrolLogDatabaseRows( $row, $extra ) {
$this->doTestLogFormatter( $row, $extra );
}
}
PK ! 7g logging/LogFormatterTestCase.phpnu Iw expandDatabaseRow( $row, $this->isLegacy( $extra ) );
$services = $this->getServiceContainer();
$userGroups = (array)$userGroups;
$userRights = $services->getGroupPermissionsLookup()->getGroupPermissions( $userGroups );
$context = new RequestContext();
$authority = $this->mockRegisteredAuthorityWithPermissions( $userRights );
$context->setAuthority( $authority );
$context->setLanguage( 'en' );
$formatter = $services->getLogFormatterFactory()->newFromRow( $row );
$formatter->setContext( $context );
// Create a LinkRenderer without LinkCache to avoid DB access
$realLinkRenderer = new LinkRenderer(
$services->getTitleFormatter(),
$this->createMock( LinkCache::class ),
$services->getSpecialPageFactory(),
$services->getHookContainer(),
new ServiceOptions(
LinkRenderer::CONSTRUCTOR_OPTIONS,
$services->getMainConfig(),
[ 'renderForComment' => false ]
)
);
// Then create a mock LinkRenderer that proxies makeLink calls to the original LinkRenderer, but assumes
// that all links are known to bypass DB access in Title::exists().
$linkRenderer = $this->createMock( LinkRenderer::class );
$linkRenderer->method( 'makeLink' )
->willReturnCallback(
static function ( $target, $text = null, $extra = [], $query = [] ) use ( $realLinkRenderer ) {
return $realLinkRenderer->makeKnownLink( $target, $text, $extra, $query );
}
);
$formatter->setLinkRenderer( $linkRenderer );
$this->setService( 'LinkRenderer', $linkRenderer );
// Create a mock PageStore where all pages are existing, in case any calls to Title::exists are not
// caught by the mocks above.
$pageStore = $this->getMockBuilder( PageStore::class )
->onlyMethods( [ 'getPageByName' ] )
->setConstructorArgs( [
new ServiceOptions( PageStore::CONSTRUCTOR_OPTIONS, $services->getMainConfig() ),
$this->createNoOpMock( ILoadBalancer::class ),
$services->getNamespaceInfo(),
$services->getTitleParser(),
null,
StatsFactory::newNull()
] )
->getMock();
$pageStore->method( 'getPageByName' )
->willReturn( $this->createMock( ExistingPageRecord::class ) );
$this->setService( 'PageStore', $pageStore );
// Create a mock UserFactory where all registered users are created with ID and name and where loading of
// other fields is prevented, to avoid DB access.
$origUserFactory = $services->getUserFactory();
$userFactory = $this->createMock( UserFactory::class );
$userFactory->method( 'newFromName' )
->willReturnCallback( static function ( $name, $validation ) use ( $origUserFactory ) {
$ret = $origUserFactory->newFromName( $name, $validation );
if ( !$ret ) {
return $ret;
}
$userID = IPUtils::isIPAddress( $name ) ? 0 : 42;
$ret = TestingAccessWrapper::newFromObject( $ret );
$ret->mId = $userID;
$ret->mLoadedItems = true;
return $ret->object;
} );
$userFactory->method( 'newFromId' )->willReturnCallback( [ $origUserFactory, 'newFromId' ] );
$userFactory->method( 'newAnonymous' )->willReturnCallback( [ $origUserFactory, 'newAnonymous' ] );
$userFactory->method( 'newFromUserIdentity' )
->willReturnCallback( [ $origUserFactory, 'newFromUserIdentity' ] );
$this->setService( 'UserFactory', $userFactory );
// Replace gender cache to avoid gender DB lookups
$genderCache = $this->createMock( GenderCache::class );
$genderCache->method( 'getGenderOf' )->willReturn( 'unknown' );
$this->setService( 'GenderCache', $genderCache );
$this->assertEquals(
$extra['text'],
self::removeSomeHtml( $formatter->getActionText() ),
'Action text is equal to expected text'
);
$this->assertSame( // ensure types and array key order
$extra['api'],
self::removeApiMetaData( $formatter->formatParametersForApi() ),
'Api log params is equal to expected array'
);
if ( isset( $extra['preload'] ) ) {
$this->assertArrayEquals(
$this->getLinkTargetsAsStrings( $extra['preload'] ),
$this->getLinkTargetsAsStrings(
$formatter->getPreloadTitles()
)
);
}
}
private function getLinkTargetsAsStrings( array $linkTargets ) {
return array_map( static function ( LinkTarget $t ) {
return $t->getInterwiki() . ':' . $t->getNamespace() . ':'
. $t->getDBkey() . '#' . $t->getFragment();
}, $linkTargets );
}
protected function isLegacy( $extra ) {
return isset( $extra['legacy'] ) && $extra['legacy'];
}
protected function expandDatabaseRow( $data, $legacy ) {
return [
// no log_id because no insert in database
'log_type' => $data['type'],
'log_action' => $data['action'],
'log_timestamp' => $data['timestamp'] ?? wfTimestampNow(),
'log_user' => $data['user'] ?? 42,
'log_user_text' => $data['user_text'] ?? 'User',
'log_actor' => $data['actor'] ?? 24,
'log_namespace' => $data['namespace'] ?? NS_MAIN,
'log_title' => $data['title'] ?? 'Main_Page',
'log_page' => $data['page'] ?? 0,
'log_comment_text' => $data['comment'] ?? '',
'log_comment_data' => null,
'log_params' => $legacy
? LogPage::makeParamBlob( $data['params'] )
: LogEntryBase::makeParamBlob( $data['params'] ),
'log_deleted' => $data['deleted'] ?? 0,
];
}
protected static function removeSomeHtml( $html ) {
$html = str_replace( '"', '"', $html );
$html = preg_replace( '/\xE2\x80[\x8E\x8F]/', '', $html ); // Strip lrm/rlm
return trim( strip_tags( $html ) );
}
protected static function removeApiMetaData( $val ) {
if ( is_array( $val ) ) {
unset( $val['_element'] );
unset( $val['_type'] );
foreach ( $val as $key => $value ) {
$val[$key] = self::removeApiMetaData( $value );
}
}
return $val;
}
}
PK ! g2B? B? user/ActorMigrationTest.phpnu Iw SCHEMA_COMPAT_WRITE_OLD | SCHEMA_COMPAT_READ_OLD,
'read-old' => SCHEMA_COMPAT_WRITE_BOTH | SCHEMA_COMPAT_READ_OLD,
'read-new' => SCHEMA_COMPAT_WRITE_BOTH | SCHEMA_COMPAT_READ_NEW,
'new' => SCHEMA_COMPAT_WRITE_NEW | SCHEMA_COMPAT_READ_NEW
];
protected function getSchemaOverrides( IMaintainableDatabase $db ) {
return [
'scripts' => [
__DIR__ . '/ActorMigrationTest.sql',
],
'drop' => [],
'create' => [ 'actormigration1', 'actormigration2' ],
'alter' => [],
];
}
private function getMigration( $stage, $actorStoreFactory = null ) {
$mwServices = $this->getServiceContainer();
return new ActorMigrationBase(
[
'am2_xxx' => [
'textField' => 'am2_xxx_text',
'actorField' => 'am2_xxx_actor'
],
],
$stage,
$actorStoreFactory ?? $mwServices->getActorStoreFactory()
);
}
private static function makeActorCases( $inputs, $expected ) {
foreach ( $expected as $inputName => $expectedCases ) {
foreach ( $expectedCases as [ $stages, $expected ] ) {
foreach ( $stages as $stage ) {
$cases[$inputName . ', ' . $stage] = array_merge(
[ $stage ],
$inputs[$inputName],
[ $expected ]
);
}
}
}
return $cases;
}
/**
* @dataProvider provideConstructor
* @param int $stage
* @param string|null $exceptionMsg
*/
public function testConstructor( $stage, $exceptionMsg ) {
try {
$m = $this->getMigration( $stage );
if ( $exceptionMsg !== null ) {
$this->fail( 'Expected exception not thrown' );
}
$this->assertInstanceOf( ActorMigrationBase::class, $m );
} catch ( InvalidArgumentException $ex ) {
$this->assertSame( $exceptionMsg, $ex->getMessage() );
}
}
public static function provideConstructor() {
return [
[ 0, '$stage must include a write mode' ],
[ SCHEMA_COMPAT_READ_OLD, '$stage must include a write mode' ],
[ SCHEMA_COMPAT_READ_NEW, '$stage must include a write mode' ],
[ SCHEMA_COMPAT_WRITE_OLD, '$stage must include a read mode' ],
[ SCHEMA_COMPAT_OLD, null ],
[ SCHEMA_COMPAT_WRITE_OLD | SCHEMA_COMPAT_READ_BOTH, 'Cannot read multiple schemas' ],
[ SCHEMA_COMPAT_WRITE_NEW, '$stage must include a read mode' ],
[
SCHEMA_COMPAT_WRITE_NEW | SCHEMA_COMPAT_READ_OLD,
'Cannot read the old schema without also writing it'
],
];
}
/**
* @dataProvider provideGetJoin
* @param string $stageName
* @param string $key
* @param array $expect
*/
public function testGetJoin( $stageName, $key, $expect ) {
$stage = self::STAGES_BY_NAME[$stageName];
$m = $this->getMigration( $stage );
$result = $m->getJoin( $key );
$this->assertEquals( $expect, $result );
}
public static function provideGetJoin() {
$inputs = [
'Simple table' => [ 'am1_user' ],
'Special name' => [ 'am2_xxx' ],
];
$expected = [
'Simple table' => [
[
[ 'old', 'read-old' ],
[
'tables' => [],
'fields' => [
'am1_user' => 'am1_user',
'am1_user_text' => 'am1_user_text',
'am1_actor' => 'NULL',
],
'joins' => [],
]
],
[
[ 'read-new', 'new' ],
[
'tables' => [ 'actor_am1_user' => 'actor' ],
'fields' => [
'am1_user' => 'actor_am1_user.actor_user',
'am1_user_text' => 'actor_am1_user.actor_name',
'am1_actor' => 'am1_actor',
],
'joins' => [
'actor_am1_user' => [ 'JOIN', 'actor_am1_user.actor_id = am1_actor' ],
],
],
],
],
'Special name' => [
[
[ 'old', 'read-old' ],
[
'tables' => [],
'fields' => [
'am2_xxx' => 'am2_xxx',
'am2_xxx_text' => 'am2_xxx_text',
'am2_xxx_actor' => 'NULL',
],
'joins' => [],
],
],
[
[ 'read-new', 'new' ],
[
'tables' => [ 'actor_am2_xxx' => 'actor' ],
'fields' => [
'am2_xxx' => 'actor_am2_xxx.actor_user',
'am2_xxx_text' => 'actor_am2_xxx.actor_name',
'am2_xxx_actor' => 'am2_xxx_actor',
],
'joins' => [
'actor_am2_xxx' => [ 'JOIN', 'actor_am2_xxx.actor_id = am2_xxx_actor' ],
],
],
],
],
];
return self::makeActorCases( $inputs, $expected );
}
private const ACTORS = [
[ 1, 'User1', 11 ],
[ 2, 'User2', 12 ],
[ 0, '192.168.12.34', 34 ],
];
private static function findRow( $table, $index, $value ) {
foreach ( $table as $row ) {
if ( $row[$index] === $value ) {
return $row;
}
}
return null;
}
/**
* @return ActorStore
*/
private function getMockActorStore() {
/** @var MockObject|ActorStore $mock */
$mock = $this->createNoOpMock( ActorStore::class, [ 'findActorId' ] );
$mock->method( 'findActorId' )
->willReturnCallback( static function ( UserIdentity $user ) {
$row = self::findRow( self::ACTORS, 1, $user->getName() );
return $row ? $row[2] : null;
} );
return $mock;
}
/**
* @return ActorStoreFactory
*/
private function getMockActorStoreFactory() {
$store = $this->getMockActorStore();
/** @var MockObject|ActorStoreFactory $mock */
$mock = $this->createNoOpMock( ActorStoreFactory::class, [ 'getActorNormalization' ] );
$mock->method( 'getActorNormalization' )
->willReturn( $store );
return $mock;
}
/**
* @dataProvider provideGetWhere
* @param string $stageName
* @param string $key
* @param UserIdentity|UserIdentity[]|null|false $users
* @param bool $useId
* @param array $expect
*/
public function testGetWhere( $stageName, $key, $users, $useId, $expect ) {
$stage = self::STAGES_BY_NAME[$stageName];
if ( !isset( $expect['conds'] ) ) {
$expect['conds'] = '(' . implode( ') OR (', $expect['orconds'] ) . ')';
}
$m = $this->getMigration( $stage, $this->getMockActorStoreFactory() );
$result = $m->getWhere( $this->getDb(), $key, $users, $useId );
$this->assertEquals( $expect, $result );
}
public static function provideGetWhere() {
$genericUser = new UserIdentityValue( 1, 'User1' );
$complicatedUsers = [
new UserIdentityValue( 1, 'User1' ),
new UserIdentityValue( 2, 'User2' ),
new UserIdentityValue( 3, 'User3' ),
new UserIdentityValue( 0, '192.168.12.34' ),
new UserIdentityValue( 0, '192.168.12.35' ),
// test handling of non-normalized IPv6 IP
new UserIdentityValue( 0, '2600:1004:b14a:5ddd:3ebe:bba4:bfba:f37e' ),
];
$inputs = [
'Simple table' => [ 'am1_user', $genericUser, true ],
'Special name' => [ 'am2_xxx', $genericUser, true ],
'Multiple users' => [ 'am1_user', $complicatedUsers, true ],
'Multiple users, no use ID' => [ 'am1_user', $complicatedUsers, false ],
'Empty $users' => [ 'am1_user', [], true ],
'Null $users' => [ 'am1_user', null, true ],
'False $users' => [ 'am1_user', false, true ],
];
$expected = [
'Simple table' => [
[
[ 'old', 'read-old' ],
[
'tables' => [],
'orconds' => [ 'userid' => "am1_user = 1" ],
'joins' => [],
]
], [
[ 'read-new', 'new' ],
[
'tables' => [],
'orconds' => [ 'newactor' => "am1_actor = 11" ],
'joins' => [],
],
],
],
'Special name' => [
[
[ 'old', 'read-old' ],
[
'tables' => [],
'orconds' => [ 'userid' => "am2_xxx = 1" ],
'joins' => [],
],
], [
[ 'read-new', 'new' ],
[
'tables' => [],
'orconds' => [ 'newactor' => "am2_xxx_actor = 11" ],
'joins' => [],
],
],
],
'Multiple users' => [
[
[ 'old', 'read-old' ],
[
'tables' => [],
'orconds' => [
'userid' => "am1_user IN (1,2,3) ",
'username' => "am1_user_text IN ('192.168.12.34','192.168.12.35',"
. "'2600:1004:B14A:5DDD:3EBE:BBA4:BFBA:F37E') "
],
'joins' => [],
]
], [
[ 'read-new', 'new' ],
[
'tables' => [],
'orconds' => [ 'newactor' => "am1_actor IN (11,12,34) " ],
'joins' => [],
]
]
],
'Multiple users, no use ID' => [
[
[ 'old', 'read-old' ],
[
'tables' => [],
'orconds' => [
'username' => "am1_user_text IN ('User1','User2','User3','192.168.12.34',"
. "'192.168.12.35','2600:1004:B14A:5DDD:3EBE:BBA4:BFBA:F37E') "
],
'joins' => [],
],
], [
[ 'read-new', 'new' ],
[
'tables' => [],
'orconds' => [ 'newactor' => "am1_actor IN (11,12,34) " ],
'joins' => [],
]
]
],
'Empty $users' => [ [
[ 'old', 'read-old', 'read-new', 'new' ],
[
'tables' => [],
'conds' => '1=0',
'orconds' => [],
'joins' => [],
],
] ],
'Null $users' => [ [
[ 'old', 'read-old', 'read-new', 'new' ],
[
'tables' => [],
'conds' => '1=0',
'orconds' => [],
'joins' => [],
],
] ],
'False $users' => [ [
[ 'old', 'read-old', 'read-new', 'new' ],
[
'tables' => [],
'conds' => '1=0',
'orconds' => [],
'joins' => [],
],
] ],
];
return self::makeActorCases( $inputs, $expected );
}
/**
* @dataProvider provideStages
*/
public function testGetWhere_exception( $stage ) {
$this->expectException( InvalidArgumentException::class );
$this->expectExceptionMessage(
'ActorMigrationBase::getWhere: Value for $users must be a UserIdentity or array, got string'
);
$m = $this->getMigration( $stage );
$m->getWhere( $this->getDb(), 'am1_user', 'Foo' );
}
/**
* @dataProvider provideInsertRoundTrip
* @param string $table
* @param string $key
* @param string $pk
*/
public function testInsertRoundTrip( $table, $key, $pk ) {
$u = $this->getTestUser()->getUser();
$user = new UserIdentityValue( $u->getId(), $u->getName() );
$stageNames = array_flip( self::STAGES_BY_NAME );
$stages = [
'old' => [
'old',
'read-old',
],
'read-old' => [
'old',
'read-old',
],
'read-new' => [
'read-new',
'new'
],
'new' => [
'read-new',
'new'
],
];
$nameKey = $key . '_text';
$actorKey = ( $key === 'am2_xxx' ? $key : substr( $key, 0, -5 ) ) . '_actor';
foreach ( $stages as $writeStageName => $possibleReadStages ) {
$writeStage = self::STAGES_BY_NAME[$writeStageName];
$w = $this->getMigration( $writeStage );
$fields = $w->getInsertValues( $this->getDb(), $key, $user );
if ( $writeStage & SCHEMA_COMPAT_WRITE_OLD ) {
$this->assertSame( $user->getId(), $fields[$key],
"old field, stage={$stageNames[$writeStage]}" );
$this->assertSame( $user->getName(), $fields[$nameKey],
"old field, stage={$stageNames[$writeStage]}" );
} else {
$this->assertArrayNotHasKey( $key, $fields, "old field, stage={$stageNames[$writeStage]}" );
$this->assertArrayNotHasKey( $nameKey, $fields, "old field, stage={$stageNames[$writeStage]}" );
}
if ( $writeStage & SCHEMA_COMPAT_WRITE_NEW ) {
$this->assertArrayHasKey( $actorKey, $fields,
"new field, stage={$stageNames[$writeStage]}" );
} else {
$this->assertArrayNotHasKey( $actorKey, $fields,
"new field, stage={$stageNames[$writeStage]}" );
}
$id = ++self::$amId;
$this->getDb()->newInsertQueryBuilder()
->insertInto( $table )
->row( [ $pk => $id ] + $fields )
->caller( __METHOD__ )
->execute();
foreach ( $possibleReadStages as $readStageName ) {
$readStage = self::STAGES_BY_NAME[$readStageName];
$r = $this->getMigration( $readStage );
$queryInfo = $r->getJoin( $key );
$row = $this->getDb()->newSelectQueryBuilder()
->queryInfo( $queryInfo )
->from( $table )
->where( [ $pk => $id ] )
->caller( __METHOD__ )
->fetchRow();
$this->assertSame( $user->getId(), (int)$row->$key,
"w={$stageNames[$writeStage]}, r={$stageNames[$readStage]}, id" );
$this->assertSame( $user->getName(), $row->$nameKey,
"w={$stageNames[$writeStage]}, r={$stageNames[$readStage]}, name" );
}
}
}
public static function provideInsertRoundTrip() {
return [
'normal' => [ 'actormigration1', 'am1_user', 'am1_id' ],
'special name' => [ 'actormigration2', 'am2_xxx', 'am2_id' ],
];
}
public static function provideStages() {
$cases = [];
foreach ( self::STAGES_BY_NAME as $name => $stage ) {
$cases[$name] = [ $stage ];
}
return $cases;
}
/**
* @dataProvider provideStages
* @param int $stage
*/
public function testInsertUserIdentity( $stage ) {
$user = $this->getMutableTestUser()->getUser();
$userIdentity = new UserIdentityValue( $user->getId(), $user->getName() );
$m = $this->getMigration( $stage );
$fields = $m->getInsertValues( $this->getDb(), 'am1_user', $userIdentity );
$id = ++self::$amId;
$this->getDb()->newInsertQueryBuilder()
->insertInto( 'actormigration1' )
->row( [ 'am1_id' => $id ] + $fields )
->caller( __METHOD__ )
->execute();
$qi = $m->getJoin( 'am1_user' );
$row = $this->getDb()->newSelectQueryBuilder()
->queryInfo( $qi )
->from( 'actormigration1' )
->where( [ 'am1_id' => $id ] )
->caller( __METHOD__ )
->fetchRow();
$this->assertSame( $user->getId(), (int)$row->am1_user );
$this->assertSame( $user->getName(), $row->am1_user_text );
$this->assertSame(
( $stage & SCHEMA_COMPAT_READ_NEW ) ? $user->getActorId() : 0,
(int)$row->am1_actor
);
$m = $this->getMigration( $stage );
$fields = $m->getInsertValues( $this->getDb(), 'dummy_user', $userIdentity );
if ( $stage & SCHEMA_COMPAT_WRITE_OLD ) {
$this->assertSame( $user->getId(), $fields['dummy_user'] );
$this->assertSame( $user->getName(), $fields['dummy_user_text'] );
} else {
$this->assertArrayNotHasKey( 'dummy_user', $fields );
$this->assertArrayNotHasKey( 'dummy_user_text', $fields );
}
if ( $stage & SCHEMA_COMPAT_WRITE_NEW ) {
$this->assertSame( $user->getActorId(), $fields['dummy_actor'] );
} else {
$this->assertArrayNotHasKey( 'dummy_actor', $fields );
}
}
public function testNewMigration() {
$m = ActorMigration::newMigration();
$this->assertInstanceOf( ActorMigration::class, $m );
$this->assertSame( $m, ActorMigration::newMigration() );
}
/**
* @dataProvider provideIsAnon
* @param string $stage
* @param string $isAnon
* @param string $isNotAnon
*/
public function testIsAnon( $stage, $isAnon, $isNotAnon ) {
$numericStage = self::STAGES_BY_NAME[$stage];
$m = $this->getMigration( $numericStage );
$this->assertSame( $isAnon, $m->isAnon( 'foo' ) );
$this->assertSame( $isNotAnon, $m->isNotAnon( 'foo' ) );
}
public static function provideIsAnon() {
return [
'old' => [ 'old', 'foo = 0', 'foo != 0' ],
'read-old' => [ 'read-old', 'foo = 0', 'foo != 0' ],
'read-new' => [ 'read-new', 'foo IS NULL', 'foo IS NOT NULL' ],
'new' => [ 'new', 'foo IS NULL', 'foo IS NOT NULL' ],
];
}
public function testCheckDeprecation() {
$m = new class(
[
'soft' => [
'deprecatedVersion' => null,
],
'hard' => [
'deprecatedVersion' => '1.34',
],
'gone' => [
'removedVersion' => '1.34',
],
],
SCHEMA_COMPAT_NEW,
$this->getServiceContainer()->getActorStoreFactory()
) extends ActorMigrationBase {
public function checkDeprecationForTest( $key ) {
$this->checkDeprecation( $key );
}
};
$this->hideDeprecated( 'MediaWiki\User\ActorMigrationBase for \'hard\'' );
$m->checkDeprecationForTest( 'valid' );
$m->checkDeprecationForTest( 'soft' );
$m->checkDeprecationForTest( 'hard' );
try {
$m->checkDeprecationForTest( 'gone' );
} catch ( InvalidArgumentException $ex ) {
$this->assertSame(
'Use of MediaWiki\User\ActorMigrationBase for \'gone\' was removed in MediaWiki 1.34',
$ex->getMessage()
);
}
}
}
PK ! 2۳5\ \ user/ActorMigrationTest.sqlnu Iw -- These are carefully crafted to work in all three supported databases
CREATE TABLE /*_*/actormigration1 (
am1_id integer not null,
am1_user integer,
am1_user_text varchar(200),
am1_actor integer
);
CREATE TABLE /*_*/actormigration2 (
am2_id integer not null,
am2_xxx integer,
am2_xxx_text varchar(200),
am2_xxx_actor integer
);
PK ! Z1" " ( user/TalkPageNotificationManagerTest.phpnu Iw getName() );
$status = $this->editPage(
$userTalk,
$text,
'',
NS_MAIN,
$this->getTestSysop()->getUser()
);
$this->assertStatusGood( $status, 'create revision of user talk' );
return $status->getNewRevision();
}
private function getManager(
bool $disableAnonTalk = false,
bool $isReadOnly = false,
?RevisionLookup $revisionLookup = null
) {
$services = $this->getServiceContainer();
return new TalkPageNotificationManager(
new ServiceOptions(
TalkPageNotificationManager::CONSTRUCTOR_OPTIONS,
new HashConfig( [
MainConfigNames::DisableAnonTalk => $disableAnonTalk
] )
),
$services->getConnectionProvider(),
$this->getDummyReadOnlyMode( $isReadOnly ),
$revisionLookup ?? $services->getRevisionLookup(),
$this->createHookContainer(),
$services->getUserFactory()
);
}
public static function provideUserHasNewMessages() {
yield 'Registered user' => [ UserIdentityValue::newRegistered( 123, 'MyName' ) ];
yield 'Anonymous user' => [ UserIdentityValue::newAnonymous( '1.2.3.4' ) ];
}
/**
* @dataProvider provideUserHasNewMessages
* @covers \MediaWiki\User\TalkPageNotificationManager::userHasNewMessages
* @covers \MediaWiki\User\TalkPageNotificationManager::setUserHasNewMessages
* @covers \MediaWiki\User\TalkPageNotificationManager::clearInstanceCache
* @covers \MediaWiki\User\TalkPageNotificationManager::removeUserHasNewMessages
*/
public function testUserHasNewMessages( UserIdentity $user ) {
$manager = $this->getManager();
$this->assertFalse( $manager->userHasNewMessages( $user ),
'Should be false before updated' );
$revRecord = $this->editUserTalk( $user, __METHOD__ );
$manager->setUserHasNewMessages( $user, $revRecord );
$this->assertTrue( $manager->userHasNewMessages( $user ),
'Should be true after updated' );
$manager->clearInstanceCache( $user );
$this->assertTrue( $manager->userHasNewMessages( $user ),
'Should be true after cache cleared' );
$manager->removeUserHasNewMessages( $user );
$this->assertFalse( $manager->userHasNewMessages( $user ),
'Should be false after updated' );
$manager->clearInstanceCache( $user );
$this->assertFalse( $manager->userHasNewMessages( $user ),
'Should be false after cache cleared' );
$manager->setUserHasNewMessages( $user, null );
$this->assertTrue( $manager->userHasNewMessages( $user ),
'Should be true after updated' );
$manager->removeUserHasNewMessages( $user );
$this->assertFalse( $manager->userHasNewMessages( $user ),
'Should be false after updated' );
}
/**
* @covers \MediaWiki\User\TalkPageNotificationManager::userHasNewMessages
* @covers \MediaWiki\User\TalkPageNotificationManager::setUserHasNewMessages
*/
public function testUserHasNewMessagesDisabledAnon() {
$user = new UserIdentityValue( 0, '1.2.3.4' );
$revRecord = $this->editUserTalk( $user, __METHOD__ );
$manager = $this->getManager( true );
$this->assertFalse( $manager->userHasNewMessages( $user ),
'New anon should have no new messages' );
$manager->setUserHasNewMessages( $user, $revRecord );
$this->assertFalse( $manager->userHasNewMessages( $user ),
'Must not set new messages for anon if disabled' );
$manager->clearInstanceCache( $user );
$this->assertFalse( $manager->userHasNewMessages( $user ),
'Must not set to database if anon messages disabled' );
}
/**
* @covers \MediaWiki\User\TalkPageNotificationManager::getLatestSeenMessageTimestamp
*/
public function testGetLatestSeenMessageTimestamp() {
$user = $this->getTestUser()->getUser();
$firstRev = $this->editUserTalk( $user, __METHOD__ . ' 1' );
$secondRev = $this->editUserTalk( $user, __METHOD__ . ' 2' );
$manager = $this->getManager();
$manager->setUserHasNewMessages( $user, $secondRev );
$this->assertSame( $firstRev->getTimestamp(), $manager->getLatestSeenMessageTimestamp( $user ) );
}
/**
* @covers \MediaWiki\User\TalkPageNotificationManager::getLatestSeenMessageTimestamp
*/
public function testGetLatestSeenMessageTimestampOutOfOrderRevision() {
$user = $this->getTestUser()->getUser();
$firstRev = $this->editUserTalk( $user, __METHOD__ . ' 1' );
$secondRev = $this->editUserTalk( $user, __METHOD__ . ' 2' );
$thirdRev = $this->editUserTalk( $user, __METHOD__ . ' 3' );
$veryOldTimestamp = MWTimestamp::convert( TS_MW, 1 );
$mockOldRev = $this->createMock( RevisionRecord::class );
$mockOldRev->method( 'getTimestamp' )
->willReturn( $veryOldTimestamp );
$mockRevLookup = $this->getMockForAbstractClass( RevisionLookup::class );
$mockRevLookup->method( 'getPreviousRevision' )
->willReturnCallback( static function ( RevisionRecord $rev )
use ( $firstRev, $secondRev, $thirdRev, $mockOldRev )
{
if ( $rev === $secondRev ) {
return $firstRev;
}
if ( $rev === $thirdRev ) {
return $mockOldRev;
}
throw new AssertionFailedError(
'RevisionLookup::getPreviousRevision called with wrong rev ' . $rev->getId()
);
} );
$manager = $this->getManager( false, false, $mockRevLookup );
$manager->setUserHasNewMessages( $user, $thirdRev );
$this->assertSame( $veryOldTimestamp, $manager->getLatestSeenMessageTimestamp( $user ) );
$manager->setUserHasNewMessages( $user, $secondRev );
$this->assertSame( $veryOldTimestamp, $manager->getLatestSeenMessageTimestamp( $user ) );
}
/**
* @covers \MediaWiki\User\TalkPageNotificationManager::getLatestSeenMessageTimestamp
*/
public function testGetLatestSeenMessageTimestampNoNewMessages() {
$user = $this->getTestUser()->getUser();
$manager = $this->getManager();
$this->assertNull( $manager->getLatestSeenMessageTimestamp( $user ),
'Must be null if no new messages' );
}
/**
* @covers \MediaWiki\User\TalkPageNotificationManager::userHasNewMessages
* @covers \MediaWiki\User\TalkPageNotificationManager::setUserHasNewMessages
* @covers \MediaWiki\User\TalkPageNotificationManager::removeUserHasNewMessages
*/
public function testDoesNotCrashOnReadOnly() {
$user = $this->getTestUser()->getUser();
$this->editUserTalk( $user, __METHOD__ );
$manager = $this->getManager( false, true );
$this->assertTrue( $manager->userHasNewMessages( $user ) );
$manager->removeUserHasNewMessages( $user );
$this->assertFalse( $manager->userHasNewMessages( $user ) );
}
/**
* @covers \MediaWiki\User\TalkPageNotificationManager::clearForPageView
*/
public function testClearForPageView() {
$user = $this->getTestUser()->getUser();
$title = $user->getTalkPage();
$revision = new MutableRevisionRecord( $title );
$revision->setPageId( 100 );
$revision->setId( 101 );
$manager = $this->getManager();
$manager->setUserHasNewMessages( $user );
$this->assertTrue( $manager->userHasNewMessages( $user ) );
// DB should have the notification
$this->newSelectQueryBuilder()
->select( 'user_id' )
->from( 'user_newtalk' )
->where( [ 'user_id' => $user->getId() ] )
->assertFieldValue( $user->getId() );
$this->getDb()->startAtomic( __METHOD__ ); // let deferred updates queue up
$updateCountBefore = DeferredUpdates::pendingUpdatesCount();
$manager->clearForPageView( $user, $revision );
// Cache should already be updated
$this->assertFalse( $manager->userHasNewMessages( $user ) );
$updateCountAfter = DeferredUpdates::pendingUpdatesCount();
$this->assertGreaterThan( $updateCountBefore, $updateCountAfter, 'An update should have been queued' );
$this->getDb()->endAtomic( __METHOD__ ); // run deferred updates
$this->assertSame( 0, DeferredUpdates::pendingUpdatesCount(), 'No pending updates' );
// Notification should have been deleted from the DB
$this->newSelectQueryBuilder()
->select( 'user_id' )
->from( 'user_newtalk' )
->where( [ 'user_id' => $user->getId() ] )
->assertEmptyResult();
}
}
PK ! gI I user/UserGroupMembershipTest.phpnu Iw setGroupPermissions(
[
'unittesters' => [
'runtest' => true,
],
'testwriters' => [
'writetest' => true,
]
]
);
}
public static function provideInstantiationValidation() {
return [
[ 1, null, null, 1, null, null ],
[ 1, 'test', null, 1, 'test', null ],
[ 1, 'test', '12345', 1, 'test', '12345' ]
];
}
/**
* @dataProvider provideInstantiationValidation
* @covers \MediaWiki\User\UserGroupMembership
*/
public function testInstantiation( $userId, $group, $expiry, $userId_, $group_, $expiry_ ) {
$ugm = new UserGroupMembership( $userId, $group, $expiry );
$this->assertSame(
$userId_,
$ugm->getUserId()
);
$this->assertSame(
$group_,
$ugm->getGroup()
);
$this->assertSame(
$expiry_,
$ugm->getExpiry()
);
}
/**
* @covers \MediaWiki\User\UserGroupMembership::equals
*/
public function testComparison() {
$ugm1 = new UserGroupMembership( 1, 'test', '67890' );
$ugm2 = new UserGroupMembership( 1, 'test', '67890' );
$ugm3 = new UserGroupMembership( 1, 'fail', '67890' );
$ugm4 = new UserGroupMembership( 1, 'fail', '12345' );
$this->assertTrue( $ugm1->equals( $ugm2 ) );
$this->assertTrue( $ugm2->equals( $ugm1 ) );
$this->assertFalse( $ugm1->equals( $ugm3 ) );
$this->assertFalse( $ugm2->equals( $ugm3 ) );
$this->assertFalse( $ugm3->equals( $ugm1 ) );
// Ensure expiry is ignored
$this->assertTrue( $ugm3->equals( $ugm4 ) );
}
/**
* @covers \MediaWiki\User\UserGroupMembership::isExpired
*/
public function testIsExpired() {
$ts = wfTimestamp( TS_MW, time() - 100 );
$ugm = new UserGroupMembership( 1, null, $ts );
$this->assertTrue(
$ugm->isExpired()
);
$ts = wfTimestamp( TS_MW, time() + 100 );
$ugm = new UserGroupMembership( 1, null, $ts );
$this->assertFalse(
$ugm->isExpired()
);
$ugm = new UserGroupMembership( 1, null, null );
$this->assertFalse(
$ugm->isExpired()
);
}
}
PK ! lķ ķ user/UserGroupManagerTest.phpnu Iw getServiceContainer();
return new UserGroupManager(
new ServiceOptions(
UserGroupManager::CONSTRUCTOR_OPTIONS,
$configOverrides,
[
MainConfigNames::AddGroups => [],
MainConfigNames::AutoConfirmAge => 0,
MainConfigNames::AutoConfirmCount => 0,
MainConfigNames::Autopromote => [
'autoconfirmed' => [ APCOND_EDITCOUNT, 0 ]
],
MainConfigNames::AutopromoteOnce => [],
MainConfigNames::GroupPermissions => [
self::GROUP => [
'runtest' => true,
]
],
MainConfigNames::GroupsAddToSelf => [],
MainConfigNames::GroupsRemoveFromSelf => [],
MainConfigNames::ImplicitGroups => [ '*', 'user', 'autoconfirmed' ],
MainConfigNames::RemoveGroups => [],
MainConfigNames::RevokePermissions => [],
],
$services->getMainConfig()
),
$services->getReadOnlyMode(),
$services->getDBLoadBalancerFactory(),
$services->getHookContainer(),
$userEditTrackerOverride ?? $services->getUserEditTracker(),
$services->getGroupPermissionsLookup(),
$services->getJobQueueGroup(),
new TestLogger(),
new RealTempUserConfig( [
'enabled' => true,
'expireAfterDays' => null,
'actions' => [ 'edit' ],
'serialProvider' => [ 'type' => 'local' ],
'serialMapping' => [ 'type' => 'plain-numeric' ],
'matchPattern' => '*Unregistered $1',
'genPattern' => '*Unregistered $1'
] ),
$callback ? [ $callback ] : []
);
}
protected function setUp(): void {
parent::setUp();
$this->expiryTime = wfTimestamp( TS_MW, time() + 100500 );
$this->clearHooks();
}
/**
* Returns a callable that must be called exactly $invokedCount times.
* @param InvokedCount $invokedCount
* @return callable|MockObject
*/
private function countPromise( $invokedCount ) {
$mockHandler = $this->getMockBuilder( \stdClass::class )
->addMethods( [ '__invoke' ] )
->getMock();
$mockHandler->expects( $invokedCount )
->method( '__invoke' );
return $mockHandler;
}
/**
* @param UserGroupManager $manager
* @param UserIdentity $user
* @param string $group
* @param string|null $expiry
*/
private function assertMembership(
UserGroupManager $manager,
UserIdentity $user,
string $group,
?string $expiry = null
) {
$this->assertContains( $group, $manager->getUserGroups( $user ) );
$memberships = $manager->getUserGroupMemberships( $user );
$this->assertArrayHasKey( $group, $memberships );
$membership = $memberships[$group];
$this->assertSame( $group, $membership->getGroup() );
$this->assertSame( $user->getId(), $membership->getUserId() );
$this->assertSame( $expiry, $membership->getExpiry() );
}
/**
* @covers \MediaWiki\User\UserGroupManager::newGroupMembershipFromRow
*/
public function testNewGroupMembershipFromRow() {
$row = new \stdClass();
$row->ug_user = '1';
$row->ug_group = __METHOD__;
$row->ug_expiry = null;
$membership = $this->getManager()->newGroupMembershipFromRow( $row );
$this->assertSame( 1, $membership->getUserId() );
$this->assertSame( __METHOD__, $membership->getGroup() );
$this->assertNull( $membership->getExpiry() );
}
/**
* @covers \MediaWiki\User\UserGroupManager::newGroupMembershipFromRow
*/
public function testNewGroupMembershipFromRowExpiring() {
$row = new \stdClass();
$row->ug_user = '1';
$row->ug_group = __METHOD__;
$row->ug_expiry = $this->expiryTime;
$membership = $this->getManager()->newGroupMembershipFromRow( $row );
$this->assertSame( 1, $membership->getUserId() );
$this->assertSame( __METHOD__, $membership->getGroup() );
$this->assertSame( $this->expiryTime, $membership->getExpiry() );
}
/**
* @covers \MediaWiki\User\UserGroupManager::getUserImplicitGroups
*/
public function testGetImplicitGroups() {
$manager = $this->getManager();
$user = $this->getTestUser( 'unittesters' )->getUser();
$this->assertArrayEquals(
[ '*', 'user', 'autoconfirmed' ],
$manager->getUserImplicitGroups( $user )
);
$user = $this->getTestUser( [ 'bureaucrat', 'test' ] )->getUser();
$this->assertArrayEquals(
[ '*', 'user', 'autoconfirmed' ],
$manager->getUserImplicitGroups( $user )
);
$this->assertTrue(
$manager->addUserToGroup( $user, self::GROUP ),
'added user to group'
);
$this->assertArrayEquals(
[ '*', 'user', 'autoconfirmed' ],
$manager->getUserImplicitGroups( $user )
);
$user = User::newFromName( 'UTUser1' );
$this->assertSame( [ '*' ], $manager->getUserImplicitGroups( $user ) );
$manager = $this->getManager( [ MainConfigNames::Autopromote => [
'dummy' => APCOND_EMAILCONFIRMED
] ] );
$user = $this->getTestUser()->getUser();
$this->assertArrayEquals(
[ '*', 'user' ],
$manager->getUserImplicitGroups( $user )
);
$this->assertArrayEquals(
[ '*', 'user' ],
$manager->getUserEffectiveGroups( $user )
);
$user->confirmEmail();
$this->assertArrayEquals(
[ '*', 'user', 'dummy' ],
$manager->getUserImplicitGroups( $user, IDBAccessObject::READ_NORMAL, true )
);
$this->assertArrayEquals(
[ '*', 'user', 'dummy' ],
$manager->getUserEffectiveGroups( $user )
);
$user = $this->getTestUser( [ 'dummy' ] )->getUser();
$user->confirmEmail();
$this->assertArrayEquals(
[ '*', 'user', 'dummy' ],
$manager->getUserImplicitGroups( $user )
);
$user = new User;
$user->setName( '*Unregistered 1234' );
$this->assertArrayEquals(
[ '*', 'temp' ],
$manager->getUserImplicitGroups( $user )
);
}
public static function provideGetEffectiveGroups() {
yield [ [], [ '*', 'user', 'autoconfirmed' ] ];
yield [ [ 'bureaucrat', 'test' ], [ '*', 'user', 'autoconfirmed', 'bureaucrat', 'test' ] ];
yield [ [ 'autoconfirmed', 'test' ], [ '*', 'user', 'autoconfirmed', 'test' ] ];
}
/**
* @dataProvider provideGetEffectiveGroups
* @covers \MediaWiki\User\UserGroupManager::getUserEffectiveGroups
*/
public function testGetEffectiveGroups( $userGroups, $effectiveGroups ) {
$manager = $this->getManager();
$user = $this->getTestUser( $userGroups )->getUser();
$this->assertArrayEquals( $effectiveGroups, $manager->getUserEffectiveGroups( $user ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::getUserEffectiveGroups
*/
public function testGetEffectiveGroupsHook() {
$manager = $this->getManager();
$user = $this->getTestUser()->getUser();
$this->setTemporaryHook(
'UserEffectiveGroups',
function ( UserIdentity $hookUser, array &$groups ) use ( $user ) {
$this->assertTrue( $hookUser->equals( $user ) );
$groups[] = 'from_hook';
}
);
$this->assertContains( 'from_hook', $manager->getUserEffectiveGroups( $user ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::addUserToGroup
* @covers \MediaWiki\User\UserGroupManager::getUserGroups
* @covers \MediaWiki\User\UserGroupManager::getUserGroupMemberships
*/
public function testAddUserToGroup() {
$manager = $this->getManager();
$user = $this->getMutableTestUser()->getUser();
$result = $manager->addUserToGroup( $user, self::GROUP );
$this->assertTrue( $result );
$this->assertMembership( $manager, $user, self::GROUP );
$manager->clearCache( $user );
$this->assertMembership( $manager, $user, self::GROUP );
// try updating without allowUpdate. Should fail
$result = $manager->addUserToGroup( $user, self::GROUP, $this->expiryTime );
$this->assertFalse( $result );
// now try updating with allowUpdate
$result = $manager->addUserToGroup( $user, self::GROUP, $this->expiryTime, true );
$this->assertTrue( $result );
$this->assertMembership( $manager, $user, self::GROUP, $this->expiryTime );
$manager->clearCache( $user );
$this->assertMembership( $manager, $user, self::GROUP, $this->expiryTime );
}
/**
* @covers \MediaWiki\User\UserGroupManager::addUserToGroup
*/
public function testAddUserToGroupReadonly() {
$user = $this->getTestUser()->getUser();
$this->getServiceContainer()->getReadOnlyMode()->setReason( 'TEST' );
$manager = $this->getManager();
$this->assertFalse( $manager->addUserToGroup( $user, 'test' ) );
$this->assertNotContains( 'test', $manager->getUserGroups( $user ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::addUserToGroup
*/
public function testAddUserToGroupAnon() {
$manager = $this->getManager();
$anon = new UserIdentityValue( 0, 'Anon' );
$this->expectException( InvalidArgumentException::class );
$manager->addUserToGroup( $anon, 'test' );
}
/**
* @covers \MediaWiki\User\UserGroupManager::addUserToGroup
*/
public function testAddUserToGroupHookAbort() {
$manager = $this->getManager();
$user = $this->getTestUser()->getUser();
$originalGroups = $manager->getUserGroups( $user );
$this->setTemporaryHook(
'UserAddGroup',
function ( UserIdentity $hookUser ) use ( $user ) {
$this->assertTrue( $hookUser->equals( $user ) );
return false;
}
);
$this->assertFalse( $manager->addUserToGroup( $user, 'test_group' ) );
$this->assertArrayEquals( $originalGroups, $manager->getUserGroups( $user ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::addUserToGroup
*/
public function testAddUserToGroupHookModify() {
$manager = $this->getManager();
$user = $this->getTestUser()->getUser();
$this->setTemporaryHook(
'UserAddGroup',
function ( UserIdentity $hookUser, &$group, &$hookExp ) use ( $user ) {
$this->assertTrue( $hookUser->equals( $user ) );
$this->assertSame( self::GROUP, $group );
$this->assertSame( $this->expiryTime, $hookExp );
$group = 'from_hook';
$hookExp = null;
return true;
}
);
$this->assertTrue( $manager->addUserToGroup( $user, self::GROUP, $this->expiryTime ) );
$this->assertContains( 'from_hook', $manager->getUserGroups( $user ) );
$this->assertNotContains( self::GROUP, $manager->getUserGroups( $user ) );
$this->assertNull( $manager->getUserGroupMemberships( $user )['from_hook']->getExpiry() );
}
/**
* @covers \MediaWiki\User\UserGroupManager::addUserToMultipleGroups
*/
public function testAddUserToMultipleGroups() {
$manager = $this->getManager();
$user = $this->getMutableTestUser()->getUser();
$manager->addUserToMultipleGroups( $user, [ self::GROUP, self::GROUP . '1' ] );
$this->assertMembership( $manager, $user, self::GROUP );
$this->assertMembership( $manager, $user, self::GROUP . '1' );
$anon = new UserIdentityValue( 0, 'Anon' );
$this->expectException( InvalidArgumentException::class );
$manager->addUserToMultipleGroups( $anon, [ self::GROUP, self::GROUP . '1' ] );
}
/**
* @covers \MediaWiki\User\UserGroupManager::getUserGroupMemberships
*/
public function testGetUserGroupMembershipsForAnon() {
$manager = $this->getManager();
$anon = new UserIdentityValue( 0, 'Anon' );
$this->assertSame( [], $manager->getUserGroupMemberships( $anon ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::getUserFormerGroups
*/
public function testGetUserFormerGroupsForAnon() {
$manager = $this->getManager();
$anon = new UserIdentityValue( 0, 'Anon' );
$this->assertSame( [], $manager->getUserFormerGroups( $anon ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::removeUserFromGroup
* @covers \MediaWiki\User\UserGroupManager::getUserFormerGroups
* @covers \MediaWiki\User\UserGroupManager::getUserGroups
* @covers \MediaWiki\User\UserGroupManager::getUserGroupMemberships
*/
public function testRemoveUserFromGroup() {
$manager = $this->getManager();
$user = $this->getMutableTestUser( [ self::GROUP ] )->getUser();
$this->assertMembership( $manager, $user, self::GROUP );
$result = $manager->removeUserFromGroup( $user, self::GROUP );
$this->assertTrue( $result );
$this->assertNotContains( self::GROUP,
$manager->getUserGroups( $user ) );
$this->assertArrayNotHasKey( self::GROUP,
$manager->getUserGroupMemberships( $user ) );
$this->assertContains( self::GROUP,
$manager->getUserFormerGroups( $user ) );
$manager->clearCache( $user );
$this->assertNotContains( self::GROUP,
$manager->getUserGroups( $user ) );
$this->assertArrayNotHasKey( self::GROUP,
$manager->getUserGroupMemberships( $user ) );
$this->assertContains( self::GROUP,
$manager->getUserFormerGroups( $user ) );
$this->assertContains( self::GROUP,
$manager->getUserFormerGroups( $user ) ); // From cache
}
/**
* @covers \MediaWiki\User\UserGroupManager::removeUserFromGroup
*/
public function testRemoveUserToGroupHookAbort() {
$manager = $this->getManager();
$user = $this->getTestUser( [ self::GROUP ] )->getUser();
$originalGroups = $manager->getUserGroups( $user );
$this->setTemporaryHook(
'UserRemoveGroup',
function ( UserIdentity $hookUser ) use ( $user ) {
$this->assertTrue( $hookUser->equals( $user ) );
return false;
}
);
$this->assertFalse( $manager->removeUserFromGroup( $user, self::GROUP ) );
$this->assertArrayEquals( $originalGroups, $manager->getUserGroups( $user ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::removeUserFromGroup
*/
public function testRemoveUserFromGroupHookModify() {
$manager = $this->getManager();
$user = $this->getTestUser( [ self::GROUP, 'from_hook' ] )->getUser();
$this->setTemporaryHook(
'UserRemoveGroup',
function ( UserIdentity $hookUser, &$group ) use ( $user ) {
$this->assertTrue( $hookUser->equals( $user ) );
$this->assertSame( self::GROUP, $group );
$group = 'from_hook';
return true;
}
);
$this->assertTrue( $manager->removeUserFromGroup( $user, self::GROUP ) );
$this->assertNotContains( 'from_hook', $manager->getUserGroups( $user ) );
$this->assertContains( self::GROUP, $manager->getUserGroups( $user ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::removeUserFromGroup
*/
public function testRemoveUserFromGroupReadOnly() {
$user = $this->getTestUser( [ 'test' ] )->getUser();
$this->getServiceContainer()->getReadOnlyMode()->setReason( 'TEST' );
$manager = $this->getManager();
$this->assertFalse( $manager->removeUserFromGroup( $user, 'test' ) );
$this->assertContains( 'test', $manager->getUserGroups( $user ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::removeUserFromGroup
*/
public function testRemoveUserFromGroupAnon() {
$manager = $this->getManager();
$anon = new UserIdentityValue( 0, 'Anon' );
$this->expectException( InvalidArgumentException::class );
$manager->removeUserFromGroup( $anon, 'test' );
}
/**
* @covers \MediaWiki\User\UserGroupManager::removeUserFromGroup
*/
public function testRemoveUserFromGroupCallback() {
$user = $this->getTestUser( [ 'test' ] )->getUser();
$calledCount = 0;
$callback = function ( UserIdentity $callbackUser ) use ( $user, &$calledCount ) {
$this->assertTrue( $callbackUser->equals( $user ) );
$calledCount += 1;
};
$manager = $this->getManager( [], null, $callback );
$this->assertTrue( $manager->removeUserFromGroup( $user, 'test' ) );
$this->assertNotContains( 'test', $manager->getUserGroups( $user ) );
$this->assertSame( 1, $calledCount );
$this->assertFalse( $manager->removeUserFromGroup( $user, 'test' ) );
$this->assertSame( 1, $calledCount );
}
/**
* @covers \MediaWiki\User\UserGroupManager::purgeExpired
*/
public function testPurgeExpired() {
$manager = $this->getManager();
$user = $this->getTestUser()->getUser();
$expiryInPast = wfTimestamp( TS_MW, time() - 100500 );
$this->assertTrue(
$manager->addUserToGroup( $user, 'expired', $expiryInPast ),
'can add expired group'
);
$manager->purgeExpired();
$this->assertNotContains( 'expired', $manager->getUserGroups( $user ) );
$this->assertArrayNotHasKey( 'expired', $manager->getUserGroupMemberships( $user ) );
$this->assertContains( 'expired', $manager->getUserFormerGroups( $user ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::purgeExpired
*/
public function testPurgeExpiredReadOnly() {
$this->getServiceContainer()->getReadOnlyMode()->setReason( 'TEST' );
$manager = $this->getManager();
$this->assertFalse( $manager->purgeExpired() );
}
/**
* @covers \MediaWiki\User\UserGroupManager::listAllGroups
*/
public function testGetAllGroups() {
$manager = $this->getManager( [
MainConfigNames::GroupPermissions => [
__METHOD__ => [ 'test' => true ],
'implicit' => [ 'test' => true ]
],
MainConfigNames::RevokePermissions => [
'revoked' => [ 'test' => true ]
],
MainConfigNames::ImplicitGroups => [ 'implicit' ]
] );
$this->assertArrayEquals( [ __METHOD__, 'revoked' ], $manager->listAllGroups() );
}
/**
* @covers \MediaWiki\User\UserGroupManager::listAllImplicitGroups
*/
public function testGetAllImplicitGroups() {
$manager = $this->getManager( [ MainConfigNames::ImplicitGroups => [ __METHOD__ ] ] );
$this->assertArrayEquals( [ __METHOD__ ], $manager->listAllImplicitGroups() );
}
/**
* @covers \MediaWiki\User\UserGroupManager::loadGroupMembershipsFromArray
*/
public function testLoadGroupMembershipsFromArray() {
$manager = $this->getManager();
$user = $this->getTestUser()->getUser();
$row = new \stdClass();
$row->ug_user = $user->getId();
$row->ug_group = 'test';
$row->ug_expiry = null;
$manager->loadGroupMembershipsFromArray( $user, [ $row ], IDBAccessObject::READ_NORMAL );
$memberships = $manager->getUserGroupMemberships( $user );
$this->assertCount( 1, $memberships );
$this->assertArrayHasKey( 'test', $memberships );
$this->assertSame( $user->getId(), $memberships['test']->getUserId() );
$this->assertSame( 'test', $memberships['test']->getGroup() );
}
public function provideGetUserAutopromoteEmailConfirmed() {
$successUserMock = $this->createNoOpMock(
User::class, [ 'getEmail', 'getEmailAuthenticationTimestamp', 'isTemp', 'assertWiki' ]
);
$successUserMock->method( 'assertWiki' )->willReturn( true );
$successUserMock->expects( $this->once() )
->method( 'getEmail' )
->willReturn( 'test@test.com' );
$successUserMock->expects( $this->once() )
->method( 'getEmailAuthenticationTimestamp' )
->willReturn( wfTimestampNow() );
yield 'Successful autopromote' => [
true, $successUserMock, [ 'test_autoconfirmed' ]
];
$emailAuthMock = $this->createNoOpMock( User::class, [ 'getEmail', 'isTemp', 'assertWiki' ] );
$emailAuthMock->method( 'assertWiki' )->willReturn( true );
$emailAuthMock->expects( $this->once() )
->method( 'getEmail' )
->willReturn( 'test@test.com' );
yield 'wgEmailAuthentication is false' => [
false, $emailAuthMock, [ 'test_autoconfirmed' ]
];
$invalidEmailMock = $this->createNoOpMock( User::class, [ 'getEmail', 'isTemp', 'assertWiki' ] );
$invalidEmailMock->method( 'assertWiki' )->willReturn( true );
$invalidEmailMock
->expects( $this->once() )
->method( 'getEmail' )
->willReturn( 'INVALID!' );
yield 'Invalid email' => [
true, $invalidEmailMock, []
];
$nullTimestampMock = $this->createNoOpMock(
User::class, [ 'getEmail', 'getEmailAuthenticationTimestamp', 'isTemp', 'assertWiki' ]
);
$nullTimestampMock->method( 'assertWiki' )->willReturn( true );
$nullTimestampMock->expects( $this->once() )
->method( 'getEmail' )
->willReturn( 'test@test.com' );
$nullTimestampMock->expects( $this->once() )
->method( 'getEmailAuthenticationTimestamp' )
->willReturn( null );
yield 'Invalid email auth timestamp' => [
true, $nullTimestampMock, []
];
}
/**
* @dataProvider provideGetUserAutopromoteEmailConfirmed
* @covers \MediaWiki\User\UserGroupManager::getUserAutopromoteGroups
* @covers \MediaWiki\User\UserGroupManager::checkCondition
* @param bool $emailAuthentication
* @param User $user
* @param array $expected
*/
public function testGetUserAutopromoteEmailConfirmed(
bool $emailAuthentication,
User $user,
array $expected
) {
$manager = $this->getManager( [
MainConfigNames::Autopromote => [ 'test_autoconfirmed' => [ APCOND_EMAILCONFIRMED ] ],
MainConfigNames::EmailAuthentication => $emailAuthentication
] );
$this->assertArrayEquals( $expected, $manager->getUserAutopromoteGroups( $user ) );
}
public static function provideGetUserAutopromoteEditCount() {
yield 'Successful promote' => [
[ APCOND_EDITCOUNT, 5 ], true, 10, [ 'test_autoconfirmed' ]
];
yield 'Required edit count negative' => [
[ APCOND_EDITCOUNT, -1 ], true, 10, [ 'test_autoconfirmed' ]
];
yield 'No edit count, use AutoConfirmCount = 11' => [
[ APCOND_EDITCOUNT ], true, 10, []
];
yield 'Null edit count, use AutoConfirmCount = 11' => [
[ APCOND_EDITCOUNT, null ], true, 13, [ 'test_autoconfirmed' ]
];
yield 'Anon' => [
[ APCOND_EDITCOUNT, 5 ], false, 100, []
];
yield 'Not enough edits' => [
[ APCOND_EDITCOUNT, 100 ], true, 10, []
];
}
/**
* @dataProvider provideGetUserAutopromoteEditCount
* @covers \MediaWiki\User\UserGroupManager::getUserAutopromoteGroups
* @covers \MediaWiki\User\UserGroupManager::checkCondition
*/
public function testGetUserAutopromoteEditCount(
array $requiredCond,
bool $userRegistered,
int $userEditCount,
array $expected
) {
$userEditTrackerMock = $this->createNoOpMock(
UserEditTracker::class,
[ 'getUserEditCount' ]
);
if ( $userRegistered ) {
$user = $this->getTestUser()->getUser();
$userEditTrackerMock->method( 'getUserEditCount' )
->with( $user )
->willReturn( $userEditCount );
} else {
$user = User::newFromName( 'UTUser1' );
}
$manager = $this->getManager(
[
MainConfigNames::AutoConfirmCount => 11,
MainConfigNames::Autopromote => [ 'test_autoconfirmed' => $requiredCond ]
],
$userEditTrackerMock
);
$this->assertArrayEquals( $expected, $manager->getUserAutopromoteGroups( $user ) );
}
public static function provideGetUserAutopromoteAge() {
yield 'Successful promote' => [
[ APCOND_AGE, 1000 ],
MWTimestamp::convert( TS_MW, time() - 1000000 ),
[ 'test_autoconfirmed' ]
];
yield 'Not old enough' => [
[ APCOND_AGE, 10000000 ], MWTimestamp::now(), []
];
yield 'Not old enough, using AutoConfirmAge via unset' => [
[ APCOND_AGE ], MWTimestamp::now(), []
];
yield 'Not old enough, using AutoConfirmAge via null' => [
[ APCOND_AGE, null ], MWTimestamp::now(), []
];
}
/**
* @dataProvider provideGetUserAutopromoteAge
* @covers \MediaWiki\User\UserGroupManager::getUserAutopromoteGroups
* @covers \MediaWiki\User\UserGroupManager::checkCondition
* @param array $requiredCondition
* @param string $registrationTs
* @param array $expected
*/
public function testGetUserAutopromoteAge(
array $requiredCondition,
string $registrationTs,
array $expected
) {
$manager = $this->getManager( [
MainConfigNames::AutoConfirmAge => 10000000,
MainConfigNames::Autopromote => [ 'test_autoconfirmed' => $requiredCondition ]
] );
$user = $this->createNoOpMock( User::class, [ 'getRegistration', 'isTemp', 'assertWiki' ] );
$user->method( 'assertWiki' )->willReturn( true );
$user->method( 'getRegistration' )
->willReturn( $registrationTs );
$this->assertArrayEquals( $expected, $manager->getUserAutopromoteGroups( $user ) );
}
public static function provideGetUserAutopromoteEditAge() {
yield 'Successful promote' => [
[ APCOND_AGE_FROM_EDIT, 1000 ],
MWTimestamp::convert( TS_MW, time() - 1000000 ),
[ 'test_autoconfirmed' ]
];
yield 'Not old enough' => [
[ APCOND_AGE_FROM_EDIT, 10000000 ], MWTimestamp::now(), []
];
}
/**
* @dataProvider provideGetUserAutopromoteEditAge
* @covers \MediaWiki\User\UserGroupManager::getUserAutopromoteGroups
* @covers \MediaWiki\User\UserGroupManager::checkCondition
* @param array $requiredCondition
* @param string $firstEditTs
* @param array $expected
*/
public function testGetUserAutopromoteEditAge(
array $requiredCondition,
string $firstEditTs,
array $expected
) {
$user = $this->getTestUser()->getUser();
$mockUserEditTracker = $this->createNoOpMock( UserEditTracker::class, [ 'getFirstEditTimestamp' ] );
$mockUserEditTracker->expects( $this->once() )
->method( 'getFirstEditTimestamp' )
->with( $user )
->willReturn( $firstEditTs );
$manager = $this->getManager( [
MainConfigNames::Autopromote => [ 'test_autoconfirmed' => $requiredCondition ]
], $mockUserEditTracker );
$this->assertArrayEquals( $expected, $manager->getUserAutopromoteGroups( $user ) );
}
public static function provideGetUserAutopromoteGroups() {
yield 'Successful promote' => [
[ 'group1', 'group2' ], [ 'group1', 'group2' ], [ 'test_autoconfirmed' ]
];
yield 'Not enough groups to promote' => [
[ 'group1', 'group2' ], [ 'group1' ], []
];
}
/**
* @dataProvider provideGetUserAutopromoteGroups
* @covers \MediaWiki\User\UserGroupManager::getUserAutopromoteGroups
* @covers \MediaWiki\User\UserGroupManager::checkCondition
*/
public function testGetUserAutopromoteGroups(
array $requiredGroups,
array $userGroups,
array $expected
) {
$user = $this->getTestUser( $userGroups )->getUser();
$manager = $this->getManager( [
MainConfigNames::Autopromote => [ 'test_autoconfirmed' => array_merge( [ APCOND_INGROUPS ], $requiredGroups ) ]
] );
$this->assertArrayEquals( $expected, $manager->getUserAutopromoteGroups( $user ) );
}
public static function provideGetUserAutopromoteIP() {
yield 'Individual ip, success' => [
[ APCOND_ISIP, '123.123.123.123' ], '123.123.123.123', [ 'test_autoconfirmed' ]
];
yield 'Individual ip, failed' => [
[ APCOND_ISIP, '123.123.123.123' ], '124.124.124.124', []
];
yield 'Range ip, success' => [
[ APCOND_IPINRANGE, '123.123.123.1/24' ], '123.123.123.123', [ 'test_autoconfirmed' ]
];
yield 'Range ip, failed' => [
[ APCOND_IPINRANGE, '123.123.123.1/24' ], '124.124.124.124', []
];
}
/**
* @dataProvider provideGetUserAutopromoteIP
* @covers \MediaWiki\User\UserGroupManager::getUserAutopromoteGroups
* @covers \MediaWiki\User\UserGroupManager::checkCondition
* @param array $condition
* @param string $userIp
* @param array $expected
*/
public function testGetUserAutopromoteIP(
array $condition,
string $userIp,
array $expected
) {
$manager = $this->getManager( [
MainConfigNames::Autopromote => [ 'test_autoconfirmed' => $condition ]
] );
$requestMock = $this->createNoOpMock( WebRequest::class, [ 'getIP' ] );
$requestMock->expects( $this->once() )
->method( 'getIP' )
->willReturn( $userIp );
$user = $this->createNoOpMock( User::class, [ 'getRequest', 'isTemp', 'assertWiki' ] );
$user->method( 'assertWiki' )->willReturn( true );
$user->expects( $this->once() )
->method( 'getRequest' )
->willReturn( $requestMock );
$this->assertArrayEquals( $expected, $manager->getUserAutopromoteGroups( $user ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::getUserAutopromoteGroups
*/
public function testGetUserAutopromoteGroupsHook() {
$manager = $this->getManager( [ MainConfigNames::Autopromote => [] ] );
$user = $this->getTestUser()->getUser();
$this->setTemporaryHook(
'GetAutoPromoteGroups',
function ( User $hookUser, array &$promote ) use ( $user ){
$this->assertTrue( $user->equals( $hookUser ) );
$this->assertSame( [], $promote );
$promote[] = 'from_hook';
}
);
$this->assertArrayEquals( [ 'from_hook' ], $manager->getUserAutopromoteGroups( $user ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::checkCondition
* @covers \MediaWiki\User\UserGroupManager::recCheckCondition
*/
public function testGetUserAutopromoteComplexCondition() {
$manager = $this->getManager( [
MainConfigNames::Autopromote => [
'test_autoconfirmed' => [ '&',
[ APCOND_INGROUPS, 'group1' ],
[ '!', [ APCOND_INGROUPS, 'group2' ] ],
[ '^', [ APCOND_INGROUPS, 'group3' ], [ APCOND_INGROUPS, 'group4' ] ],
[ '|', [ APCOND_INGROUPS, 'group5' ], [ APCOND_INGROUPS, 'group6' ] ]
]
]
] );
$this->assertSame( [], $manager->getUserAutopromoteGroups(
$this->getTestUser( [ 'group1' ] )->getUser() )
);
$this->assertSame( [], $manager->getUserAutopromoteGroups(
$this->getTestUser( [ 'group1', 'group2' ] )->getUser() )
);
$this->assertSame( [], $manager->getUserAutopromoteGroups(
$this->getTestUser( [ 'group1', 'group3', 'group4' ] )->getUser() )
);
$this->assertSame( [], $manager->getUserAutopromoteGroups(
$this->getTestUser( [ 'group1', 'group3' ] )->getUser() )
);
$this->assertArrayEquals(
[ 'test_autoconfirmed' ],
$manager->getUserAutopromoteGroups( $this->getTestUser( [ 'group1', 'group3', 'group5' ] )->getUser() )
);
}
/**
* @covers \MediaWiki\User\UserGroupManager::getUserAutopromoteGroups
* @covers \MediaWiki\User\UserGroupManager::checkCondition
*/
public function testGetUserAutopromoteBot() {
$manager = $this->getManager( [
MainConfigNames::Autopromote => [ 'test_autoconfirmed' => [ APCOND_ISBOT ] ]
] );
$notBot = $this->getTestUser()->getUser();
$this->assertSame( [], $manager->getUserAutopromoteGroups( $notBot ) );
$bot = $this->getTestUser( [ 'bot' ] )->getUser();
$this->assertArrayEquals( [ 'test_autoconfirmed' ],
$manager->getUserAutopromoteGroups( $bot ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::getUserAutopromoteGroups
* @covers \MediaWiki\User\UserGroupManager::checkCondition
*/
public function testGetUserAutopromoteBlocked() {
$manager = $this->getManager( [
MainConfigNames::Autopromote => [ 'test_autoconfirmed' => [ APCOND_BLOCKED ] ]
] );
$nonBlockedUser = $this->getTestUser()->getUser();
$this->assertSame( [], $manager->getUserAutopromoteGroups( $nonBlockedUser ) );
$blockedUser = $this->getTestUser( [ 'blocked' ] )->getUser();
$block = new DatabaseBlock();
$block->setTarget( $blockedUser );
$block->setBlocker( $this->getTestSysop()->getUser() );
$block->isSitewide( true );
$this->getServiceContainer()->getDatabaseBlockStore()->insertBlock( $block );
$this->assertArrayEquals( [ 'test_autoconfirmed' ],
$manager->getUserAutopromoteGroups( $blockedUser ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::getUserAutopromoteGroups
* @covers \MediaWiki\User\UserGroupManager::checkCondition
*/
public function testGetUserAutopromoteBlockedDoesNotRecurse() {
// Make sure session handling is started
if ( !PHPSessionHandler::isInstalled() ) {
PHPSessionHandler::install(
SessionManager::singleton()
);
}
$oldSessionId = session_id();
$context = RequestContext::getMain();
// Variables are unused but needed to reproduce the failure
$oInfo = $context->exportSession();
$user = User::newFromName( 'UnitTestContextUser' );
$user->addToDatabase();
$sinfo = [
'sessionId' => 'd612ee607c87e749ef14da4983a702cd',
'userId' => $user->getId(),
'ip' => '192.0.2.0',
'headers' => [
'USER-AGENT' => 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:18.0) Gecko/20100101 Firefox/18.0'
]
];
$this->overrideConfigValue(
MainConfigNames::Autopromote,
[ 'test_autoconfirmed' => [ '&', APCOND_BLOCKED ] ]
);
// Variables are unused but needed to reproduce the failure
$sc = RequestContext::importScopedSession( $sinfo ); // load new context
$info = $context->exportSession();
$this->assertNull( $user->getBlock() );
}
/**
* @covers \MediaWiki\User\UserGroupManager::getUserAutopromoteGroups
* @covers \MediaWiki\User\UserGroupManager::checkCondition
*/
public function testGetUserAutopromoteBlockedDoesNotRecurseWithHook() {
$this->overrideConfigValue(
MainConfigNames::Autopromote,
[ 'test_autoconfirmed' => [ '&', APCOND_BLOCKED ] ]
);
// Make sure session handling is started
if ( !PHPSessionHandler::isInstalled() ) {
PHPSessionHandler::install(
SessionManager::singleton()
);
}
$permissionManager = $this->getServiceContainer()->getPermissionManager();
$permissionManager->invalidateUsersRightsCache();
$oldSessionId = session_id();
$context = RequestContext::getMain();
// Variables are unused but needed to reproduce the failure
$oInfo = $context->exportSession();
$user = User::newFromName( 'UnitTestContextUser' );
$user->addToDatabase();
$sinfo = [
'sessionId' => 'd612ee607c87e749ef14da4983a702cd',
'userId' => $user->getId(),
'ip' => '192.0.2.0',
'headers' => [
'USER-AGENT' => 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:18.0) Gecko/20100101 Firefox/18.0'
]
];
$onGetUserBlockCalled = false;
$this->setTemporaryHook(
'GetUserBlock',
static function ( $user, $ip, &$block ) use ( $permissionManager, &$onGetUserBlockCalled ) {
$onGetUserBlockCalled = true;
try {
if ( $permissionManager->userHasAnyRight( $user, 'ipblock-exempt', 'globalblock-exempt' ) ) {
return true;
}
} catch ( LogicException $e ) {
// We expect an uncaught LogicException from UserGroupManager::checkCondition here
// otherwise there's something else wrong!
if ( !str_starts_with( $e->getMessage(), "Unexpected recursion!" ) ) {
throw $e;
}
}
return true;
}
);
// Variables are unused but needed to reproduce the failure
$sc = RequestContext::importScopedSession( $sinfo ); // load new context
$info = $context->exportSession();
$this->assertNull( $user->getBlock() );
$this->assertTrue(
$onGetUserBlockCalled,
'Check that HookRunner::onGetUserBlock was called'
);
}
/**
* @covers \MediaWiki\User\UserGroupManager::getUserAutopromoteGroups
*/
public function testGetUserAutopromoteInvalid() {
$manager = $this->getManager( [
MainConfigNames::Autopromote => [ 'test_autoconfirmed' => [ 999 ] ]
] );
$user = $this->getTestUser()->getUser();
$this->expectException( InvalidArgumentException::class );
$manager->getUserAutopromoteGroups( $user );
}
/**
* @covers \MediaWiki\User\UserGroupManager::getUserAutopromoteGroups
* @covers \MediaWiki\User\UserGroupManager::checkCondition
*/
public function testGetUserAutopromoteConditionHook() {
$user = $this->getTestUser()->getUser();
$this->setTemporaryHook(
'AutopromoteCondition',
function ( $type, array $arg, User $hookUser, &$result ) use ( $user ){
$this->assertTrue( $user->equals( $hookUser ) );
$this->assertSame( 999, $type );
$this->assertSame( 'ARGUMENT', $arg[0] );
$result = true;
}
);
$manager = $this->getManager( [
MainConfigNames::Autopromote => [ 'test_autoconfirmed' => [ 999, 'ARGUMENT' ] ]
] );
$this->assertArrayEquals( [ 'test_autoconfirmed' ], $manager->getUserAutopromoteGroups( $user ) );
}
public static function provideGetUserAutopromoteOnce() {
yield 'Events are not matching' => [
[ 'NOT_EVENT' => [ 'autopromoteonce' => [ APCOND_EDITCOUNT, 0 ] ] ], [], [], []
];
yield 'Empty config' => [
[ 'EVENT' => [] ], [], [], []
];
yield 'Simple case, not user groups, not former groups' => [
[ 'EVENT' => [ 'autopromoteonce' => [ APCOND_EDITCOUNT, 0 ] ] ], [], [], [ 'autopromoteonce' ]
];
yield 'User already in the group' => [
[ 'EVENT' => [ 'autopromoteonce' => [ APCOND_EDITCOUNT, 0 ] ] ], [], [ 'autopromoteonce' ], []
];
yield 'User used to be in the group' => [
[ 'EVENT' => [ 'autopromoteonce' => [ APCOND_EDITCOUNT, 0 ] ] ], [ 'autopromoteonce' ], [], []
];
}
/**
* @dataProvider provideGetUserAutopromoteOnce
* @covers \MediaWiki\User\UserGroupManager::getUserAutopromoteOnceGroups
* @param array $config
* @param array $formerGroups
* @param array $userGroups
* @param array $expected
*/
public function testGetUserAutopromoteOnce(
array $config,
array $formerGroups,
array $userGroups,
array $expected
) {
$manager = $this->getManager( [ MainConfigNames::AutopromoteOnce => $config ] );
$user = $this->getTestUser()->getUser();
$manager->addUserToMultipleGroups( $user, $userGroups );
foreach ( $formerGroups as $formerGroup ) {
$manager->addUserToGroup( $user, $formerGroup );
$manager->removeUserFromGroup( $user, $formerGroup );
}
$this->assertArrayEquals( $userGroups, $manager->getUserGroups( $user ),
false, 'user groups are correct ' );
$this->assertArrayEquals( $formerGroups, $manager->getUserFormerGroups( $user ),
false, 'user former groups are correct ' );
$this->assertArrayEquals(
$expected,
$manager->getUserAutopromoteOnceGroups( $user, 'EVENT' )
);
}
/**
* @covers \MediaWiki\User\UserGroupManager::addUserToAutopromoteOnceGroups
*/
public function testAddUserToAutopromoteOnceGroupsForeignDomain() {
$siteConfig = new SiteConfiguration();
$siteConfig->wikis = [ 'TEST_DOMAIN' ];
$this->setMwGlobals( 'wgConf', $siteConfig );
$this->overrideConfigValue( MainConfigNames::LocalDatabases, [ 'TEST_DOMAIN' ] );
$manager = $this->getServiceContainer()
->getUserGroupManagerFactory()
->getUserGroupManager( 'TEST_DOMAIN' );
$user = $this->getTestUser()->getUser();
$this->expectException( PreconditionException::class );
$this->assertSame( [], $manager->addUserToAutopromoteOnceGroups( $user, 'TEST' ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::addUserToAutopromoteOnceGroups
*/
public function testAddUserToAutopromoteOnceGroupsAnon() {
$manager = $this->getManager();
$anon = new UserIdentityValue( 0, 'TEST' );
$this->assertSame( [], $manager->addUserToAutopromoteOnceGroups( $anon, 'TEST' ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::addUserToAutopromoteOnceGroups
*/
public function testAddUserToAutopromoteOnceGroupsReadOnly() {
$manager = $this->getManager();
$user = $this->getTestUser()->getUser();
$this->getServiceContainer()->getReadOnlyMode()->setReason( 'TEST' );
$this->assertSame( [], $manager->addUserToAutopromoteOnceGroups( $user, 'TEST' ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::addUserToAutopromoteOnceGroups
*/
public function testAddUserToAutopromoteOnceGroupsNoGroups() {
$manager = $this->getManager();
$user = $this->getTestUser()->getUser();
$this->assertSame( [], $manager->addUserToAutopromoteOnceGroups( $user, 'TEST' ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::addUserToAutopromoteOnceGroups
*/
public function testAddUserToAutopromoteOnceGroupsSuccess() {
$user = $this->getTestUser()->getUser();
$manager = $this->getManager( [
MainConfigNames::AutopromoteOnce => [ 'EVENT' => [ 'autopromoteonce' => [ APCOND_EDITCOUNT, 0 ] ] ]
] );
$this->assertNotContains( 'autopromoteonce', $manager->getUserGroups( $user ) );
$hookCalled = false;
$this->setTemporaryHook(
'UserGroupsChanged',
function ( User $hookUser, array $added, array $removed ) use ( $user, &$hookCalled ) {
$this->assertTrue( $user->equals( $hookUser ) );
$this->assertArrayEquals( [ 'autopromoteonce' ], $added );
$this->assertSame( [], $removed );
$hookCalled = true;
}
);
$manager->addUserToAutopromoteOnceGroups( $user, 'EVENT' );
$this->assertContains( 'autopromoteonce', $manager->getUserGroups( $user ) );
$this->assertTrue( $hookCalled );
$this->newSelectQueryBuilder()
->select( [ 'log_type', 'log_action', 'log_params' ] )
->from( 'logging' )
->where( [ 'log_type' => 'rights' ] )
->assertResultSet( [ [ 'rights',
'autopromote',
LogEntryBase::makeParamBlob( [
'4::oldgroups' => [],
'5::newgroups' => [ 'autopromoteonce' ],
] )
] ] );
}
private const CHANGEABLE_GROUPS_TEST_CONFIG = [
MainConfigNames::GroupPermissions => [],
MainConfigNames::AddGroups => [
'sysop' => [ 'rollback' ],
'bureaucrat' => [ 'sysop', 'bureaucrat' ],
],
MainConfigNames::RemoveGroups => [
'sysop' => [ 'rollback' ],
'bureaucrat' => [ 'sysop' ],
],
MainConfigNames::GroupsAddToSelf => [
'sysop' => [ 'flood' ],
],
MainConfigNames::GroupsRemoveFromSelf => [
'flood' => [ 'flood' ],
],
];
private function assertGroupsEquals( array $expected, array $actual ) {
// assertArrayEquals can compare without requiring the same order,
// but the elements of an array are still required to be in the same order,
// so just compare each element
$this->assertArrayEquals( $expected['add'], $actual['add'], 'Add must match' );
$this->assertArrayEquals( $expected['remove'], $actual['remove'], 'Remove must match' );
$this->assertArrayEquals( $expected['add-self'], $actual['add-self'], 'Add-self must match' );
$this->assertArrayEquals( $expected['remove-self'], $actual['remove-self'], 'Remove-self must match' );
}
/**
* @covers \MediaWiki\User\UserGroupManager::getGroupsChangeableBy
*/
public function testChangeableGroups() {
$manager = $this->getManager( self::CHANGEABLE_GROUPS_TEST_CONFIG );
$allGroups = $manager->listAllGroups();
$user = $this->getTestUser()->getUser();
$changeableGroups = $manager->getGroupsChangeableBy( new SimpleAuthority( $user, [ 'userrights' ] ) );
$this->assertGroupsEquals(
[
'add' => $allGroups,
'remove' => $allGroups,
'add-self' => [],
'remove-self' => [],
],
$changeableGroups
);
$user = $this->getTestUser( [ 'bureaucrat', 'sysop' ] )->getUser();
$changeableGroups = $manager->getGroupsChangeableBy( new SimpleAuthority( $user, [] ) );
$this->assertGroupsEquals(
[
'add' => [ 'sysop', 'bureaucrat', 'rollback' ],
'remove' => [ 'sysop', 'rollback' ],
'add-self' => [ 'flood' ],
'remove-self' => [],
],
$changeableGroups
);
$user = $this->getTestUser( [ 'flood' ] )->getUser();
$changeableGroups = $manager->getGroupsChangeableBy( new SimpleAuthority( $user, [] ) );
$this->assertGroupsEquals(
[
'add' => [],
'remove' => [],
'add-self' => [],
'remove-self' => [ 'flood' ],
],
$changeableGroups
);
}
public static function provideChangeableByGroup() {
yield 'sysop' => [ 'sysop', [
'add' => [ 'rollback' ],
'remove' => [ 'rollback' ],
'add-self' => [ 'flood' ],
'remove-self' => [],
] ];
yield 'flood' => [ 'flood', [
'add' => [],
'remove' => [],
'add-self' => [],
'remove-self' => [ 'flood' ],
] ];
}
/**
* @dataProvider provideChangeableByGroup
* @covers \MediaWiki\User\UserGroupManager::getGroupsChangeableByGroup
* @param string $group
* @param array $expected
*/
public function testChangeableByGroup( string $group, array $expected ) {
$manager = $this->getManager( self::CHANGEABLE_GROUPS_TEST_CONFIG );
$this->assertGroupsEquals( $expected, $manager->getGroupsChangeableByGroup( $group ) );
}
/**
* @covers \MediaWiki\User\UserGroupManager::getUserPrivilegedGroups()
*/
public function testGetUserPrivilegedGroups() {
$this->overrideConfigValue( MainConfigNames::PrivilegedGroups, [ 'sysop', 'interface-admin', 'bar', 'baz' ] );
$makeHook = function ( $invocationCount, User $userToMatch, array $groupsToAdd ) {
return function ( $u, &$groups ) use ( $userToMatch, $invocationCount, $groupsToAdd ) {
$invocationCount();
$this->assertTrue( $userToMatch->equals( $u ) );
$groups = array_merge( $groups, $groupsToAdd );
};
};
$manager = $this->getManager();
$user = new User;
$user->setName( '*Unregistered 1234' );
$this->assertArrayEquals(
[],
$manager->getUserPrivilegedGroups( $user )
);
$user = $this->getTestUser( [ 'sysop', 'bot', 'interface-admin' ] )->getUser();
$this->setTemporaryHook( 'UserPrivilegedGroups',
$makeHook( $this->countPromise( $this->once() ), $user, [ 'foo' ] ) );
$this->setTemporaryHook( 'UserEffectiveGroups',
$makeHook( $this->countPromise( $this->once() ), $user, [ 'bar', 'boom' ] ) );
$this->assertArrayEquals(
[ 'sysop', 'interface-admin', 'foo', 'bar' ],
$manager->getUserPrivilegedGroups( $user )
);
$this->assertArrayEquals(
[ 'sysop', 'interface-admin', 'foo', 'bar' ],
$manager->getUserPrivilegedGroups( $user )
);
$this->setTemporaryHook( 'UserPrivilegedGroups',
$makeHook( $this->countPromise( $this->once() ), $user, [ 'baz' ] ) );
$this->setTemporaryHook( 'UserEffectiveGroups',
$makeHook( $this->countPromise( $this->once() ), $user, [ 'baz' ] ) );
$this->assertArrayEquals(
[ 'sysop', 'interface-admin', 'foo', 'bar' ],
$manager->getUserPrivilegedGroups( $user )
);
$this->assertArrayEquals(
[ 'sysop', 'interface-admin', 'baz' ],
$manager->getUserPrivilegedGroups( $user, IDBAccessObject::READ_NORMAL, true )
);
$this->assertArrayEquals(
[ 'sysop', 'interface-admin', 'baz' ],
$manager->getUserPrivilegedGroups( $user )
);
$this->setTemporaryHook( 'UserPrivilegedGroups', static function () {
} );
$this->setTemporaryHook( 'UserEffectiveGroups', static function () {
} );
$user = $this->getTestUser( [] )->getUser();
$this->assertArrayEquals(
[],
$manager->getUserPrivilegedGroups( $user, IDBAccessObject::READ_NORMAL, true )
);
}
}
PK ! @[overrideConfigValues( [
MainConfigNames::EnableBotPasswords => true,
MainConfigNames::CentralIdLookupProvider => 'BotPasswordTest OkMock',
MainConfigNames::GrantPermissions => [
'test' => [ 'read' => true ],
],
MainConfigNames::UserrightsInterwikiDelimiter => '@',
] );
$this->testUser = $this->getMutableTestUser();
$this->testUserName = $this->testUser->getUser()->getName();
$mock1 = $this->getMockForAbstractClass( CentralIdLookup::class );
$mock1->method( 'isAttached' )
->willReturn( true );
$mock1->method( 'lookupUserNames' )
->willReturn( [ $this->testUserName => 42, 'UTDummy' => 43, 'UTInvalid' => 0 ] );
$mock1->expects( $this->never() )->method( 'lookupCentralIds' );
$mock2 = $this->getMockForAbstractClass( CentralIdLookup::class );
$mock2->method( 'isAttached' )
->willReturn( false );
$mock2->method( 'lookupUserNames' )
->willReturnArgument( 0 );
$mock2->expects( $this->never() )->method( 'lookupCentralIds' );
$this->mergeMwGlobalArrayValue( 'wgCentralIdLookupProviders', [
'BotPasswordTest OkMock' => [ 'factory' => static function () use ( $mock1 ) {
return $mock1;
} ],
'BotPasswordTest FailMock' => [ 'factory' => static function () use ( $mock2 ) {
return $mock2;
} ],
] );
}
public function addDBData() {
$passwordFactory = $this->getServiceContainer()->getPasswordFactory();
$passwordHash = $passwordFactory->newFromPlaintext( 'foobaz' );
$dbw = $this->getDb();
$dbw->newDeleteQueryBuilder()
->deleteFrom( 'bot_passwords' )
->where( [ 'bp_user' => [ 42, 43 ], 'bp_app_id' => 'BotPassword' ] )
->caller( __METHOD__ )->execute();
$dbw->newInsertQueryBuilder()
->insertInto( 'bot_passwords' )
->row( [
'bp_user' => 42,
'bp_app_id' => 'BotPassword',
'bp_password' => $passwordHash->toString(),
'bp_token' => 'token!',
'bp_restrictions' => '{"IPAddresses":["127.0.0.0/8"]}',
'bp_grants' => '["test"]',
] )
->row( [
'bp_user' => 43,
'bp_app_id' => 'BotPassword',
'bp_password' => $passwordHash->toString(),
'bp_token' => 'token!',
'bp_restrictions' => '{"IPAddresses":["127.0.0.0/8"]}',
'bp_grants' => '["test"]',
] )
->caller( __METHOD__ )
->execute();
}
public function testBasics() {
$user = $this->testUser->getUser();
$bp = BotPassword::newFromUser( $user, 'BotPassword' );
$this->assertInstanceOf( BotPassword::class, $bp );
$this->assertTrue( $bp->isSaved() );
$this->assertSame( 42, $bp->getUserCentralId() );
$this->assertSame( 'BotPassword', $bp->getAppId() );
$this->assertSame( 'token!', trim( $bp->getToken(), " \0" ) );
$this->assertEquals( '{"IPAddresses":["127.0.0.0/8"]}', $bp->getRestrictions()->toJson() );
$this->assertSame( [ 'test' ], $bp->getGrants() );
$this->assertNull( BotPassword::newFromUser( $user, 'DoesNotExist' ) );
$this->overrideConfigValue( MainConfigNames::CentralIdLookupProvider, 'BotPasswordTest FailMock' );
$this->assertNull( BotPassword::newFromUser( $user, 'BotPassword' ) );
$this->assertSame( '@', BotPassword::getSeparator() );
$this->overrideConfigValue( MainConfigNames::UserrightsInterwikiDelimiter, '#' );
$this->assertSame( '#', BotPassword::getSeparator() );
}
public function testUnsaved() {
$user = $this->testUser->getUser();
$bp = BotPassword::newUnsaved( [
'user' => $user,
'appId' => 'DoesNotExist'
] );
$this->assertInstanceOf( BotPassword::class, $bp );
$this->assertFalse( $bp->isSaved() );
$this->assertSame( 42, $bp->getUserCentralId() );
$this->assertSame( 'DoesNotExist', $bp->getAppId() );
$this->assertEquals( MWRestrictions::newDefault(), $bp->getRestrictions() );
$this->assertSame( [], $bp->getGrants() );
$bp = BotPassword::newUnsaved( [
'username' => 'UTDummy',
'appId' => 'DoesNotExist2',
'restrictions' => MWRestrictions::newFromJson( '{"IPAddresses":["127.0.0.0/8"]}' ),
'grants' => [ 'test' ],
] );
$this->assertInstanceOf( BotPassword::class, $bp );
$this->assertFalse( $bp->isSaved() );
$this->assertSame( 43, $bp->getUserCentralId() );
$this->assertSame( 'DoesNotExist2', $bp->getAppId() );
$this->assertEquals( '{"IPAddresses":["127.0.0.0/8"]}', $bp->getRestrictions()->toJson() );
$this->assertSame( [ 'test' ], $bp->getGrants() );
$bp = BotPassword::newUnsaved( [
'centralId' => 45,
'appId' => 'DoesNotExist'
] );
$this->assertInstanceOf( BotPassword::class, $bp );
$this->assertFalse( $bp->isSaved() );
$this->assertSame( 45, $bp->getUserCentralId() );
$this->assertSame( 'DoesNotExist', $bp->getAppId() );
$user = $this->testUser->getUser();
$bp = BotPassword::newUnsaved( [
'user' => $user,
'appId' => 'BotPassword'
] );
$this->assertInstanceOf( BotPassword::class, $bp );
$this->assertFalse( $bp->isSaved() );
$this->assertNull( BotPassword::newUnsaved( [
'user' => $user,
'appId' => '',
] ) );
$this->assertNull( BotPassword::newUnsaved( [
'user' => $user,
'appId' => str_repeat( 'X', BotPassword::APPID_MAXLENGTH + 1 ),
] ) );
$this->assertNull( BotPassword::newUnsaved( [
'user' => $this->testUserName,
'appId' => 'Ok',
] ) );
$this->assertNull( BotPassword::newUnsaved( [
'username' => 'UTInvalid',
'appId' => 'Ok',
] ) );
$this->assertNull( BotPassword::newUnsaved( [
'appId' => 'Ok',
] ) );
}
public function testGetPassword() {
/** @var BotPassword $bp */
$bp = TestingAccessWrapper::newFromObject( BotPassword::newFromCentralId( 42, 'BotPassword' ) );
$password = $bp->getPassword();
$this->assertInstanceOf( Password::class, $password );
$this->assertTrue( $password->verify( 'foobaz' ) );
$bp->centralId = 44;
$password = $bp->getPassword();
$this->assertInstanceOf( InvalidPassword::class, $password );
$bp = TestingAccessWrapper::newFromObject( BotPassword::newFromCentralId( 42, 'BotPassword' ) );
$dbw = $this->getDb();
$dbw->newUpdateQueryBuilder()
->update( 'bot_passwords' )
->set( [ 'bp_password' => 'garbage' ] )
->where( [ 'bp_user' => 42, 'bp_app_id' => 'BotPassword' ] )
->caller( __METHOD__ )->execute();
$password = $bp->getPassword();
$this->assertInstanceOf( InvalidPassword::class, $password );
}
public function testInvalidateAllPasswordsForUser() {
$bp1 = TestingAccessWrapper::newFromObject( BotPassword::newFromCentralId( 42, 'BotPassword' ) );
$bp2 = TestingAccessWrapper::newFromObject( BotPassword::newFromCentralId( 43, 'BotPassword' ) );
$this->assertNotInstanceOf( InvalidPassword::class, $bp1->getPassword() );
$this->assertNotInstanceOf( InvalidPassword::class, $bp2->getPassword() );
BotPassword::invalidateAllPasswordsForUser( $this->testUserName );
$this->assertInstanceOf( InvalidPassword::class, $bp1->getPassword() );
$this->assertNotInstanceOf( InvalidPassword::class, $bp2->getPassword() );
$bp = TestingAccessWrapper::newFromObject( BotPassword::newFromCentralId( 42, 'BotPassword' ) );
$this->assertInstanceOf( InvalidPassword::class, $bp->getPassword() );
}
public function testRemoveAllPasswordsForUser() {
$this->assertNotNull( BotPassword::newFromCentralId( 42, 'BotPassword' ) );
$this->assertNotNull( BotPassword::newFromCentralId( 43, 'BotPassword' ) );
BotPassword::removeAllPasswordsForUser( $this->testUserName );
$this->assertNull( BotPassword::newFromCentralId( 42, 'BotPassword' ) );
$this->assertNotNull( BotPassword::newFromCentralId( 43, 'BotPassword' ) );
}
/**
* @dataProvider provideCanonicalizeLoginData
*/
public function testCanonicalizeLoginData( $username, $password, $expectedResult ) {
$result = BotPassword::canonicalizeLoginData( $username, $password );
if ( is_array( $expectedResult ) ) {
$this->assertArrayEquals( $expectedResult, $result, true, true );
} else {
$this->assertSame( $expectedResult, $result );
}
}
public static function provideCanonicalizeLoginData() {
return [
// T388255
[ '', '', false ],
[ 'user', '', false ],
[ '', '12345678901234567890123456789012', false ],
[ 'user', 'pass', false ],
[ 'user', 'abc@def', false ],
[ 'legacy@user', 'pass', false ],
[ 'user@bot', '12345678901234567890123456789012',
[ 'user@bot', '12345678901234567890123456789012' ] ],
[ 'user', 'bot@12345678901234567890123456789012',
[ 'user@bot', '12345678901234567890123456789012' ] ],
[ 'user', 'bot@12345678901234567890123456789012345',
[ 'user@bot', '12345678901234567890123456789012345' ] ],
[ 'user', 'bot@x@12345678901234567890123456789012',
[ 'user@bot@x', '12345678901234567890123456789012' ] ],
];
}
public function testLogin() {
// Test failure when bot passwords aren't enabled
$this->overrideConfigValue( MainConfigNames::EnableBotPasswords, false );
$status = BotPassword::login( "{$this->testUserName}@BotPassword", 'foobaz', new FauxRequest );
$this->assertEquals( Status::newFatal( 'botpasswords-disabled' ), $status );
$this->overrideConfigValue( MainConfigNames::EnableBotPasswords, true );
// Test failure when BotPasswordSessionProvider isn't configured
$manager = new SessionManager( [
'logger' => new Psr\Log\NullLogger,
'store' => new EmptyBagOStuff,
] );
$reset = TestUtils::setSessionManagerSingleton( $manager );
$this->assertNull(
$manager->getProvider( MediaWiki\Session\BotPasswordSessionProvider::class )
);
$status = BotPassword::login( "{$this->testUserName}@BotPassword", 'foobaz', new FauxRequest );
$this->assertEquals( Status::newFatal( 'botpasswords-no-provider' ), $status );
ScopedCallback::consume( $reset );
// Now configure BotPasswordSessionProvider for further tests...
$mainConfig = $this->getServiceContainer()->getMainConfig();
$config = new HashConfig( [
MainConfigNames::SessionProviders => $mainConfig->get( MainConfigNames::SessionProviders ) + [
MediaWiki\Session\BotPasswordSessionProvider::class => [
'class' => MediaWiki\Session\BotPasswordSessionProvider::class,
'args' => [ [ 'priority' => 40 ] ],
'services' => [ 'GrantsInfo' ],
]
],
] );
$manager = new SessionManager( [
'config' => new MultiConfig( [ $config, $mainConfig ] ),
'logger' => new Psr\Log\NullLogger,
'store' => new EmptyBagOStuff,
] );
$reset = TestUtils::setSessionManagerSingleton( $manager );
// No "@"-thing in the username
$status = BotPassword::login( $this->testUserName, 'foobaz', new FauxRequest );
$this->assertStatusError( 'botpasswords-invalid-name', $status );
// No base user
$status = BotPassword::login( 'UTDummy@BotPassword', 'foobaz', new FauxRequest );
$this->assertStatusError( 'nosuchuser', $status );
// No bot password
$status = BotPassword::login( "{$this->testUserName}@DoesNotExist", 'foobaz', new FauxRequest );
$this->assertStatusError( 'botpasswords-not-exist', $status );
// Failed restriction
$request = $this->getMockBuilder( FauxRequest::class )
->onlyMethods( [ 'getIP' ] )
->getMock();
$request->method( 'getIP' )
->willReturn( '10.0.0.1' );
$status = BotPassword::login( "{$this->testUserName}@BotPassword", 'foobaz', $request );
$this->assertStatusError( 'botpasswords-restriction-failed', $status );
// Wrong password
$status = BotPassword::login(
"{$this->testUserName}@BotPassword", $this->testUser->getPassword(), new FauxRequest );
$this->assertStatusError( 'wrongpassword', $status );
// Success!
$request = new FauxRequest;
$this->assertNotInstanceOf(
MediaWiki\Session\BotPasswordSessionProvider::class,
$request->getSession()->getProvider()
);
$status = BotPassword::login( "{$this->testUserName}@BotPassword", 'foobaz', $request );
$this->assertInstanceOf( Status::class, $status );
$this->assertStatusGood( $status );
$session = $status->getValue();
$this->assertInstanceOf( MediaWiki\Session\Session::class, $session );
$this->assertInstanceOf(
MediaWiki\Session\BotPasswordSessionProvider::class, $session->getProvider()
);
$this->assertSame( $session->getId(), $request->getSession()->getId() );
ScopedCallback::consume( $reset );
}
/**
* @dataProvider provideSave
* @param string|null $password
*/
public function testSave( $password ) {
$passwordFactory = $this->getServiceContainer()->getPasswordFactory();
$bp = BotPassword::newUnsaved( [
'centralId' => 42,
'appId' => 'TestSave',
'restrictions' => MWRestrictions::newFromJson( '{"IPAddresses":["127.0.0.0/8"]}' ),
'grants' => [ 'test' ],
] );
$this->assertFalse( $bp->isSaved() );
$this->assertNull(
BotPassword::newFromCentralId( 42, 'TestSave', IDBAccessObject::READ_LATEST )
);
$passwordHash = $password ? $passwordFactory->newFromPlaintext( $password ) : null;
$this->assertStatusNotOk( $bp->save( 'update', $passwordHash ) );
$this->assertStatusGood( $bp->save( 'insert', $passwordHash ) );
$bp2 = BotPassword::newFromCentralId( 42, 'TestSave', IDBAccessObject::READ_LATEST );
$this->assertInstanceOf( BotPassword::class, $bp2 );
$this->assertEquals( $bp->getUserCentralId(), $bp2->getUserCentralId() );
$this->assertEquals( $bp->getAppId(), $bp2->getAppId() );
$this->assertEquals( $bp->getToken(), $bp2->getToken() );
$this->assertEquals( $bp->getRestrictions(), $bp2->getRestrictions() );
$this->assertEquals( $bp->getGrants(), $bp2->getGrants() );
/** @var Password $pw */
$pw = TestingAccessWrapper::newFromObject( $bp )->getPassword();
if ( $password === null ) {
$this->assertInstanceOf( InvalidPassword::class, $pw );
} else {
$this->assertTrue( $pw->verify( $password ) );
}
$token = $bp->getToken();
$this->assertEquals( 42, $bp->getUserCentralId() );
$this->assertEquals( 'TestSave', $bp->getAppId() );
$this->assertStatusNotOk( $bp->save( 'insert' ) );
$this->assertStatusGood( $bp->save( 'update' ) );
$this->assertNotEquals( $token, $bp->getToken() );
$bp2 = BotPassword::newFromCentralId( 42, 'TestSave', IDBAccessObject::READ_LATEST );
$this->assertInstanceOf( BotPassword::class, $bp2 );
$this->assertEquals( $bp->getToken(), $bp2->getToken() );
/** @var Password $pw */
$pw = TestingAccessWrapper::newFromObject( $bp )->getPassword();
if ( $password === null ) {
$this->assertInstanceOf( InvalidPassword::class, $pw );
} else {
$this->assertTrue( $pw->verify( $password ) );
}
$passwordHash = $passwordFactory->newFromPlaintext( 'XXX' );
$token = $bp->getToken();
$this->assertStatusGood( $bp->save( 'update', $passwordHash ) );
$this->assertNotEquals( $token, $bp->getToken() );
/** @var Password $pw */
$pw = TestingAccessWrapper::newFromObject( $bp )->getPassword();
$this->assertTrue( $pw->verify( 'XXX' ) );
$this->assertTrue( $bp->delete() );
$this->assertFalse( $bp->isSaved() );
$this->assertNull( BotPassword::newFromCentralId( 42, 'TestSave', IDBAccessObject::READ_LATEST ) );
$this->expectException( UnexpectedValueException::class );
$bp->save( 'foobar' )->isGood();
}
public static function provideSave() {
return [
[ null ],
[ 'foobar' ],
];
}
/**
* Tests for error handling when bp_restrictions and bp_grants are too long
*/
public function testSaveValidation() {
$lotsOfIPs = [
'IPAddresses' => array_fill(
0,
5000,
"127.0.0.0/8"
)
];
$bp = BotPassword::newUnsaved( [
'centralId' => 42,
'appId' => 'TestSave',
// When this becomes JSON, it'll be 70,017 characters, which is
// greater than BotPassword::GRANTS_MAXLENGTH, so it will cause an error.
'restrictions' => MWRestrictions::newFromArray( $lotsOfIPs ),
'grants' => [
// Maximum length of the JSON is BotPassword::RESTRICTIONS_MAXLENGTH characters.
// So one long grant name should be good. Turning it into JSON will add
// a couple of extra characters, taking it over BotPassword::RESTRICTIONS_MAXLENGTH
// characters long, so it will cause an error.
str_repeat( '*', BotPassword::RESTRICTIONS_MAXLENGTH )
],
] );
$status = $bp->save( 'insert' );
$this->assertStatusError( 'botpasswords-toolong-restrictions', $status );
$this->assertStatusError( 'botpasswords-toolong-grants', $status );
}
}
PK ! YZ user/ExternalUserNamesTest.phpnu Iw User1',
Title::makeTitle( NS_MAIN, ':User:User1', '', 'valid' )
],
[
'Valid user name that looks like an import source, from known import source',
'valid:valid:>User1',
Title::makeTitle( NS_MAIN, 'valid::User:User1', '', 'valid' )
],
[
'Local IP address',
'127.0.0.1',
Title::makeTitle( NS_SPECIAL, 'Contributions/127.0.0.1', '', '' )
],
[
'Valid user name from unknown import source',
'invalid:>User1',
null
],
[
'Corrupt local user name with linebreak',
"Foo\nBar",
null
],
[
'Corrupt local user name with terminal underscore',
'Barf_',
null
],
[
'Corrupt local user name with initial lowercase',
'abcd',
null
],
[
'Corrupt local user name with slash',
'For/Bar',
null
],
[
'Corrupt local user name with octothorpe',
'For#Bar',
null
],
];
}
/**
* @covers \MediaWiki\User\ExternalUserNames::getUserLinkTitle
* @dataProvider provideGetUserLinkTitle
*/
public function testGetUserLinkTitle( $caseDescription, $username, $expected ) {
$this->setContentLang( 'en' );
$interwikiLookup = $this->getDummyInterwikiLookup( [ 'valid' ] );
$this->setService( 'InterwikiLookup', $interwikiLookup );
$this->assertEquals(
$expected,
ExternalUserNames::getUserLinkTitle( $username ),
$caseDescription
);
}
public static function provideApplyPrefix() {
return [
[ 'User1', 'prefix', 'prefix>User1' ],
[ 'User1', 'prefix:>', 'prefix>User1' ],
[ 'User1', 'prefix:', 'prefix>User1' ],
[ 'user1', 'prefix', 'prefix>user1' ],
[ '0', 'prefix', 'prefix>0' ],
[ 'Unknown user', 'prefix', 'Unknown user' ],
];
}
/**
* @covers \MediaWiki\User\ExternalUserNames::applyPrefix
* @dataProvider provideApplyPrefix
*/
public function testApplyPrefix( $username, $prefix, $expected ) {
$externalUserNames = new ExternalUserNames( $prefix, true );
$this->assertSame(
$expected,
$externalUserNames->applyPrefix( $username )
);
}
/**
* @covers \MediaWiki\User\ExternalUserNames::applyPrefix
*/
public function testApplyPrefix_existingUser() {
$testName = $this->getTestUser()->getUser()->getName();
$testName2 = lcfirst( $testName );
$this->assertNotSame( $testName, $testName2 );
$externalUserNames = new ExternalUserNames( 'p', false );
$this->assertSame( "p>$testName", $externalUserNames->applyPrefix( $testName ) );
$this->assertSame( "p>$testName2", $externalUserNames->applyPrefix( $testName2 ) );
$externalUserNames = new ExternalUserNames( 'p', true );
$this->assertSame( $testName, $externalUserNames->applyPrefix( $testName ) );
$this->assertSame( $testName2, $externalUserNames->applyPrefix( $testName2 ) );
}
public static function provideAddPrefix() {
return [
[ 'User1', 'prefix', 'prefix>User1' ],
[ 'User2', 'prefix2', 'prefix2>User2' ],
[ 'User3', 'prefix3', 'prefix3>User3' ],
];
}
/**
* @covers \MediaWiki\User\ExternalUserNames::addPrefix
* @dataProvider provideAddPrefix
*/
public function testAddPrefix( $username, $prefix, $expected ) {
$externalUserNames = new ExternalUserNames( $prefix, true );
$this->assertSame(
$expected,
$externalUserNames->addPrefix( $username )
);
}
public static function provideIsExternal() {
return [
[ 'User1', false ],
[ '>User1', true ],
[ 'prefix>User1', true ],
[ 'prefix:>User1', true ],
];
}
/**
* @covers \MediaWiki\User\ExternalUserNames::isExternal
* @dataProvider provideIsExternal
*/
public function testIsExternal( $username, $expected ) {
$this->assertSame(
$expected,
ExternalUserNames::isExternal( $username )
);
}
public static function provideGetLocal() {
return [
[ 'User1', 'User1' ],
[ '>User2', 'User2' ],
[ 'prefix>User3', 'User3' ],
[ 'prefix:>User4', 'User4' ],
];
}
/**
* @covers \MediaWiki\User\ExternalUserNames::getLocal
* @dataProvider provideGetLocal
*/
public function testGetLocal( $username, $expected ) {
$this->assertSame(
$expected,
ExternalUserNames::getLocal( $username )
);
}
}
PK ! i9 9 user/LocalIdLookupTest.phpnu Iw localUsers[] = $this->getMutableTestUser()->getUserIdentity();
}
$sysop = static::getTestSysop()->getUserIdentity();
$blockStore = $this->getServiceContainer()->getDatabaseBlockStore();
$block = new DatabaseBlock( [
'address' => $this->localUsers[2]->getName(),
'by' => $sysop,
'reason' => __METHOD__,
'expiry' => '1 day',
'hideName' => false,
] );
$blockStore->insertBlock( $block );
$block = new DatabaseBlock( [
'address' => $this->localUsers[3]->getName(),
'by' => $sysop,
'reason' => __METHOD__,
'expiry' => '1 day',
'hideName' => true,
] );
$blockStore->insertBlock( $block );
}
private function newLookup( array $configOverride = [] ) {
$lookup = new LocalIdLookup(
new HashConfig( [
MainConfigNames::SharedDB => null,
MainConfigNames::SharedTables => [],
MainConfigNames::LocalDatabases => [],
] + $configOverride ),
$this->getServiceContainer()->getConnectionProvider(),
$this->getServiceContainer()->getHideUserUtils()
);
$lookup->init(
'test',
$this->getServiceContainer()->getUserIdentityLookup(),
$this->getServiceContainer()->getUserFactory()
);
return $lookup;
}
public function testLookupCentralIds() {
$lookup = $this->newLookup();
$permitted = $this->mockAnonAuthorityWithPermissions( [ 'hideuser' ] );
$nonPermitted = $this->mockAnonAuthorityWithoutPermissions( [ 'hideuser' ] );
$this->assertSame( [], $lookup->lookupCentralIds( [] ) );
$expect = [];
foreach ( $this->localUsers as $localUser ) {
$expect[$localUser->getId()] = $localUser->getName();
}
$expect[12345] = 'X';
ksort( $expect );
$expect2 = $expect;
$expect2[$this->localUsers[3]->getId()] = '';
$arg = array_fill_keys( array_keys( $expect ), 'X' );
$this->assertSame( $expect2, $lookup->lookupCentralIds( $arg ) );
$this->assertSame( $expect, $lookup->lookupCentralIds( $arg, CentralIdLookup::AUDIENCE_RAW ) );
$this->assertSame( $expect, $lookup->lookupCentralIds( $arg, $permitted ) );
$this->assertSame( $expect2, $lookup->lookupCentralIds( $arg, $nonPermitted ) );
}
public function testLookupUserNames() {
$lookup = $this->newLookup();
$permitted = $this->mockAnonAuthorityWithPermissions( [ 'hideuser' ] );
$nonPermitted = $this->mockAnonAuthorityWithoutPermissions( [ 'hideuser' ] );
$this->assertSame( [], $lookup->lookupUserNames( [] ) );
$expect = [];
foreach ( $this->localUsers as $localUser ) {
$expect[$localUser->getName()] = $localUser->getId();
}
$expect['UTDoesNotExist'] = 'X';
ksort( $expect );
$expect2 = $expect;
$expect2[$this->localUsers[3]->getName()] = 'X';
$arg = array_fill_keys( array_keys( $expect ), 'X' );
$this->assertSame( $expect2, $lookup->lookupUserNames( $arg ) );
$this->assertSame( $expect, $lookup->lookupUserNames( $arg, CentralIdLookup::AUDIENCE_RAW ) );
$this->assertSame( $expect, $lookup->lookupUserNames( $arg, $permitted ) );
$this->assertSame( $expect2, $lookup->lookupUserNames( $arg, $nonPermitted ) );
}
public function testIsAttached() {
$lookup = $this->newLookup();
$user1 = UserIdentityValue::newRegistered( 42, 'Test' );
$user2 = UserIdentityValue::newAnonymous( 'DoesNotExist' );
$this->assertTrue( $lookup->isAttached( $user1 ) );
$this->assertFalse( $lookup->isAttached( $user2 ) );
$wiki = UserIdentityValue::LOCAL;
$this->assertTrue( $lookup->isAttached( $user1, $wiki ) );
$this->assertFalse( $lookup->isAttached( $user2, $wiki ) );
$wiki = 'some_other_wiki';
$this->assertFalse( $lookup->isAttached( $user1, $wiki ) );
$this->assertFalse( $lookup->isAttached( $user2, $wiki ) );
}
/**
* @dataProvider provideIsAttachedShared
* @param bool $sharedDB $wgSharedDB is set
* @param bool $sharedTable $wgSharedTables contains 'user'
* @param bool $localDBSet $wgLocalDatabases contains the shared DB
*/
public function testIsAttachedShared( $sharedDB, $sharedTable, $localDBSet ) {
$lookup = $this->newLookup( [
MainConfigNames::SharedDB => $sharedDB ? "dummy" : null,
MainConfigNames::SharedTables => $sharedTable ? [ 'user' ] : [],
MainConfigNames::LocalDatabases => $localDBSet ? [ 'shared' ] : [],
] );
$this->assertSame(
$sharedDB && $sharedTable && $localDBSet,
$lookup->isAttached( UserIdentityValue::newRegistered( 42, 'Test' ), 'shared' )
);
}
public static function provideIsAttachedShared() {
$ret = [];
for ( $i = 0; $i < 7; $i++ ) {
$ret[] = [
(bool)( $i & 1 ),
(bool)( $i & 2 ),
(bool)( $i & 4 ),
];
}
return $ret;
}
}
PK ! v v user/UserTest.phpnu Iw ';
/**
* @var User
*/
protected $user;
protected function setUp(): void {
parent::setUp();
$this->overrideConfigValues( [
MainConfigNames::GroupPermissions => [],
MainConfigNames::RevokePermissions => [],
MainConfigNames::UseRCPatrol => true,
MainConfigNames::WatchlistExpiry => true,
MainConfigNames::AutoConfirmAge => 0,
MainConfigNames::AutoConfirmCount => 0,
] );
$this->setUpPermissionGlobals();
$this->user = $this->getTestUser( 'unittesters' )->getUser();
}
private function setUpPermissionGlobals() {
$this->setGroupPermissions( [
// Data for regular $wgGroupPermissions test
'unittesters' => [
'test' => true,
'runtest' => true,
'writetest' => false,
'nukeworld' => false,
'autoconfirmed' => false,
],
'testwriters' => [
'test' => true,
'writetest' => true,
'modifytest' => true,
'autoconfirmed' => true,
],
// For the options and watchlist tests
'*' => [
'editmyoptions' => true,
'editmywatchlist' => true,
'viewmywatchlist' => true,
],
// For patrol tests
'patroller' => [
'patrol' => true,
],
// For account creation when blocked test
'accountcreator' => [
'createaccount' => true,
'ipblock-exempt' => true
],
// For bot and ratelimit tests
'bot' => [
'bot' => true,
'noratelimit' => true,
]
] );
$this->overrideConfigValue(
MainConfigNames::RevokePermissions,
// Data for regular $wgRevokePermissions test
[ 'formertesters' => [ 'runtest' => true ] ]
);
}
private function setSessionUser( User $user, WebRequest $request ) {
RequestContext::getMain()->setUser( $user );
RequestContext::getMain()->setRequest( $request );
TestingAccessWrapper::newFromObject( $user )->mRequest = $request;
$request->getSession()->setUser( $user );
}
/**
* @covers \MediaWiki\User\User::isAllowedAny
* @covers \MediaWiki\User\User::isAllowedAll
* @covers \MediaWiki\User\User::isAllowed
* @covers \MediaWiki\User\User::isNewbie
*/
public function testIsAllowed() {
$this->assertFalse(
$this->user->isAllowed( 'writetest' ),
'Basic isAllowed works with a group not granted a right'
);
$this->assertTrue(
$this->user->isAllowedAny( 'test', 'writetest' ),
'A user with only one of the rights can pass isAllowedAll'
);
$this->assertTrue(
$this->user->isAllowedAll( 'test', 'runtest' ),
'A user with multiple rights can pass isAllowedAll'
);
$this->assertFalse(
$this->user->isAllowedAll( 'test', 'runtest', 'writetest' ),
'A user needs all rights specified to pass isAllowedAll'
);
$this->assertTrue(
$this->user->isNewbie(),
'Unit testers are not autoconfirmed yet'
);
$user = $this->getTestUser( 'testwriters' )->getUser();
$this->assertTrue(
$user->isAllowed( 'test' ),
'Basic isAllowed works with a group granted a right'
);
$this->assertTrue(
$user->isAllowed( 'writetest' ),
'Testwriters pass isAllowed with `writetest`'
);
$this->assertFalse(
$user->isNewbie(),
'Test writers are autoconfirmed'
);
}
/**
* @covers \MediaWiki\User\User::useRCPatrol
* @covers \MediaWiki\User\User::useNPPatrol
* @covers \MediaWiki\User\User::useFilePatrol
*/
public function testPatrolling() {
$user = $this->getTestUser( 'patroller' )->getUser();
$this->assertTrue( $user->useRCPatrol() );
$this->assertTrue( $user->useNPPatrol() );
$this->assertTrue( $user->useFilePatrol() );
$this->assertFalse( $this->user->useRCPatrol() );
$this->assertFalse( $this->user->useNPPatrol() );
$this->assertFalse( $this->user->useFilePatrol() );
}
/**
* @covers \MediaWiki\User\User::isBot
*/
public function testBot() {
$user = $this->getTestUser( 'bot' )->getUser();
$userGroupManager = $this->getServiceContainer()->getUserGroupManager();
$this->assertSame( [ 'bot' ], $userGroupManager->getUserGroups( $user ) );
$this->assertArrayHasKey( 'bot', $userGroupManager->getUserGroupMemberships( $user ) );
$this->assertTrue( $user->isBot() );
$this->assertArrayNotHasKey( 'bot', $userGroupManager->getUserGroupMemberships( $this->user ) );
$this->assertFalse( $this->user->isBot() );
}
/**
* Test User::editCount
* @group medium
* @covers \MediaWiki\User\User::getEditCount
*/
public function testGetEditCount() {
$user = $this->getMutableTestUser()->getUser();
// let the user have a few (3) edits
$title = Title::makeTitle( NS_HELP, 'UserTest_EditCount' );
for ( $i = 0; $i < 3; $i++ ) {
$this->editPage(
$title,
(string)$i,
'test',
NS_MAIN,
$user
);
}
$this->assertSame(
3,
$user->getEditCount(),
'After three edits, the user edit count should be 3'
);
// increase the edit count
$this->getServiceContainer()->getUserEditTracker()->incrementUserEditCount( $user );
$user->clearInstanceCache();
$this->assertSame(
4,
$user->getEditCount(),
'After increasing the edit count manually, the user edit count should be 4'
);
}
/**
* Test User::editCount
* @group medium
* @covers \MediaWiki\User\User::getEditCount
*/
public function testGetEditCountForAnons() {
$user = User::newFromName( 'Anonymous' );
$this->assertNull(
$user->getEditCount(),
'Edit count starts null for anonymous users.'
);
$this->assertNull(
$this->getServiceContainer()->getUserEditTracker()->incrementUserEditCount( $user ),
'Edit count cannot be increased for anonymous users'
);
$this->assertNull(
$user->getEditCount(),
'Edit count remains null for anonymous users despite calls to increase it.'
);
}
/**
* @covers \MediaWiki\User\User::getRightDescription
*/
public function testGetRightDescription() {
$key = 'deletechangetags';
$parsedDescription = User::getRightDescription( $key );
$this->assertMatchesRegularExpression( '/[|]/', $parsedDescription );
}
/**
* @covers \MediaWiki\User\User::getRightDescriptionHtml
*/
public function testGetParsedRightDescription() {
$key = 'deletechangetags';
$parsedDescription = User::getRightDescriptionHtml( $key );
$this->assertMatchesRegularExpression( '/<.*>/', $parsedDescription );
}
/**
* Test password validity checks. There are 3 checks in core:
* - ensure the password meets the minimal length
* - ensure the password is not the same as the username
* - ensure the username/password combo isn't forbidden
* @covers \MediaWiki\User\User::checkPasswordValidity()
* @covers \MediaWiki\User\User::isValidPassword()
*/
public function testCheckPasswordValidity() {
$this->overrideConfigValue(
MainConfigNames::PasswordPolicy,
[
'policies' => [
'sysop' => [
'MinimalPasswordLength' => 8,
'MinimumPasswordLengthToLogin' => 1,
'PasswordCannotBeSubstringInUsername' => 1,
],
'default' => [
'MinimalPasswordLength' => 6,
'PasswordCannotBeSubstringInUsername' => true,
'PasswordCannotMatchDefaults' => true,
'MaximalPasswordLength' => 40,
],
],
'checks' => [
'MinimalPasswordLength' => 'MediaWiki\Password\PasswordPolicyChecks::checkMinimalPasswordLength',
'MinimumPasswordLengthToLogin' => 'MediaWiki\Password\PasswordPolicyChecks::checkMinimumPasswordLengthToLogin',
'PasswordCannotBeSubstringInUsername' =>
'MediaWiki\Password\PasswordPolicyChecks::checkPasswordCannotBeSubstringInUsername',
'PasswordCannotMatchDefaults' => 'MediaWiki\Password\PasswordPolicyChecks::checkPasswordCannotMatchDefaults',
'MaximalPasswordLength' => 'MediaWiki\Password\PasswordPolicyChecks::checkMaximalPasswordLength',
],
]
);
$this->assertTrue( $this->user->isValidPassword( 'Password1234' ) );
// Minimum length
$this->assertFalse( $this->user->isValidPassword( 'a' ) );
$status = $this->user->checkPasswordValidity( 'a' );
$this->assertStatusWarning( 'passwordtooshort', $status );
// Maximum length
$longPass = str_repeat( 'a', 41 );
$this->assertFalse( $this->user->isValidPassword( $longPass ) );
$status = $this->user->checkPasswordValidity( $longPass );
$this->assertStatusError( 'passwordtoolong', $status );
// Matches username
$status = $this->user->checkPasswordValidity( $this->user->getName() );
$this->assertStatusWarning( 'password-substring-username-match', $status );
$this->setTemporaryHook( 'isValidPassword', static function ( $password, &$result, $user ) {
$result = 'isValidPassword returned false';
return false;
} );
$status = $this->user->checkPasswordValidity( 'Password1234' );
$this->assertStatusWarning( 'isValidPassword returned false', $status );
$this->removeTemporaryHook( 'isValidPassword' );
$this->setTemporaryHook( 'isValidPassword', static function ( $password, &$result, $user ) {
$result = true;
return true;
} );
$status = $this->user->checkPasswordValidity( 'Password1234' );
$this->assertStatusGood( $status );
$this->removeTemporaryHook( 'isValidPassword' );
$this->setTemporaryHook( 'isValidPassword', static function ( $password, &$result, $user ) {
$result = 'isValidPassword returned true';
return true;
} );
$status = $this->user->checkPasswordValidity( 'Password1234' );
$this->assertStatusWarning( 'isValidPassword returned true', $status );
$this->removeTemporaryHook( 'isValidPassword' );
// On the forbidden list
$user = User::newFromName( 'Useruser' );
$status = $user->checkPasswordValidity( 'Passpass' );
$this->assertStatusWarning( 'password-login-forbidden', $status );
}
/**
* @covers \MediaWiki\User\User::equals
*/
public function testEquals() {
$first = $this->getMutableTestUser()->getUser();
$second = User::newFromName( $first->getName() );
$this->assertTrue( $first->equals( $first ) );
$this->assertTrue( $first->equals( $second ) );
$this->assertTrue( $second->equals( $first ) );
$third = $this->getMutableTestUser()->getUser();
$fourth = $this->getMutableTestUser()->getUser();
$this->assertFalse( $third->equals( $fourth ) );
$this->assertFalse( $fourth->equals( $third ) );
// Test users loaded from db with id
$user = $this->getMutableTestUser()->getUser();
$fifth = User::newFromId( $user->getId() );
$sixth = User::newFromName( $user->getName() );
$this->assertTrue( $fifth->equals( $sixth ) );
}
/**
* @covers \MediaWiki\User\User::getId
* @covers \MediaWiki\User\User::setId
*/
public function testUserId() {
$this->assertGreaterThan( 0, $this->user->getId() );
$user = User::newFromName( 'UserWithNoId' );
$this->assertSame( 0, $user->getId() );
$user->setId( 7 );
$this->assertSame(
7,
$user->getId(),
'Manually setting a user id via ::setId is reflected in ::getId'
);
$user = new User;
$user->setName( '1.2.3.4' );
$this->assertSame(
0,
$user->getId(),
'IPs have an id of 0'
);
}
/**
* @covers \MediaWiki\User\User::isRegistered
* @covers \MediaWiki\User\User::isAnon
* @covers \MediaWiki\User\User::logOut
*/
public function testIsRegistered() {
$user = $this->getMutableTestUser()->getUser();
$this->assertTrue( $user->isRegistered() );
$this->assertFalse( $user->isAnon() );
$this->setTemporaryHook( 'UserLogout', static function ( &$user ) {
return false;
} );
$user->logout();
$this->assertTrue( $user->isRegistered() );
$this->removeTemporaryHook( 'UserLogout' );
$user->logout();
$this->assertFalse( $user->isRegistered() );
// Non-existent users are perceived as anonymous
$user = User::newFromName( 'UTNonexistent' );
$this->assertFalse( $user->isRegistered() );
$this->assertTrue( $user->isAnon() );
$user = new User;
$this->assertFalse( $user->isRegistered() );
$this->assertTrue( $user->isAnon() );
}
/**
* @covers \MediaWiki\User\User::setRealName
* @covers \MediaWiki\User\User::getRealName
*/
public function testRealName() {
$user = $this->getMutableTestUser()->getUser();
$realName = 'John Doe';
$user->setRealName( $realName );
$this->assertSame(
$realName,
$user->getRealName(),
'Real name retrieved from cache'
);
$id = $user->getId();
$user->saveSettings();
$otherUser = User::newFromId( $id );
$this->assertSame(
$realName,
$otherUser->getRealName(),
'Real name retrieved from database'
);
}
/**
* @covers \MediaWiki\User\User::checkAndSetTouched
* @covers \MediaWiki\User\User::getDBTouched()
*/
public function testCheckAndSetTouched() {
$user = $this->getMutableTestUser()->getUser();
$user = TestingAccessWrapper::newFromObject( $user );
$this->assertTrue( $user->isRegistered() );
$touched = $user->getDBTouched();
$this->assertTrue(
$user->checkAndSetTouched(), "checkAndSetTouched() succedeed" );
$this->assertGreaterThan(
$touched, $user->getDBTouched(), "user_touched increased with casOnTouched()" );
$touched = $user->getDBTouched();
$this->assertTrue(
$user->checkAndSetTouched(), "checkAndSetTouched() succedeed #2" );
$this->assertGreaterThan(
$touched, $user->getDBTouched(), "user_touched increased with casOnTouched() #2" );
}
/**
* @covers \MediaWiki\User\User::validateCache
* @covers \MediaWiki\User\User::getTouched
*/
public function testValidateCache() {
$user = $this->getTestUser()->getUser();
$initialTouchMW = $user->getTouched();
$initialTouchUnix = ( new MWTimestamp( $initialTouchMW ) )->getTimestamp();
$earlierUnix = $initialTouchUnix - 1000;
$earlierMW = ( new MWTimestamp( $earlierUnix ) )->getTimestamp( TS_MW );
$this->assertFalse(
$user->validateCache( $earlierMW ),
'Caches from before the value of getTouched() are not valid'
);
$laterUnix = $initialTouchUnix + 1000;
$laterMW = ( new MWTimestamp( $laterUnix ) )->getTimestamp( TS_MW );
$this->assertTrue(
$user->validateCache( $laterMW ),
'Caches from after the value of getTouched() are valid'
);
}
/**
* @covers \MediaWiki\User\User::findUsersByGroup
*/
public function testFindUsersByGroup() {
$users = User::findUsersByGroup( [] );
$this->assertSame( 0, iterator_count( $users ) );
$users = User::findUsersByGroup( 'foo', 1, 1 );
$this->assertSame( 0, iterator_count( $users ) );
$user = $this->getMutableTestUser( [ 'foo' ] )->getUser();
$users = User::findUsersByGroup( 'foo' );
$this->assertSame( 1, iterator_count( $users ) );
$users->rewind();
$this->assertTrue( $user->equals( $users->current() ) );
// arguments have OR relationship
$user2 = $this->getMutableTestUser( [ 'bar' ] )->getUser();
$users = User::findUsersByGroup( [ 'foo', 'bar' ] );
$this->assertSame( 2, iterator_count( $users ) );
$users->rewind();
$this->assertTrue( $user->equals( $users->current() ) );
$users->next();
$this->assertTrue( $user2->equals( $users->current() ) );
// users are not duplicated
$user = $this->getMutableTestUser( [ 'baz', 'boom' ] )->getUser();
$users = User::findUsersByGroup( [ 'baz', 'boom' ] );
$this->assertSame( 1, iterator_count( $users ) );
$users->rewind();
$this->assertTrue( $user->equals( $users->current() ) );
}
/**
* @covers \MediaWiki\User\User::getBlock
*/
public function testSoftBlockRanges() {
$this->overrideConfigValue( MainConfigNames::SoftBlockRanges, [ '10.0.0.0/8' ] );
// IP isn't in $wgSoftBlockRanges
$user = new User();
$request = new FauxRequest();
$request->setIP( '192.168.0.1' );
$this->setSessionUser( $user, $request );
$this->assertNull( $user->getBlock() );
// IP is in $wgSoftBlockRanges
$user = new User();
$request = new FauxRequest();
$request->setIP( '10.20.30.40' );
$this->setSessionUser( $user, $request );
$block = $user->getBlock();
$this->assertInstanceOf( SystemBlock::class, $block );
$this->assertSame( 'wgSoftBlockRanges', $block->getSystemBlockType() );
// IP is in $wgSoftBlockRanges and user is temporary
$this->enableAutoCreateTempUser();
$user = ( new TestUser( '~1' ) )->getUser();
$request = new FauxRequest();
$request->setIP( '10.20.30.40' );
$this->setSessionUser( $user, $request );
$block = $user->getBlock();
$this->assertTrue( $user->isTemp() );
$this->assertInstanceOf( SystemBlock::class, $block );
$this->assertSame( 'wgSoftBlockRanges', $block->getSystemBlockType() );
// Make sure the block is really soft
$request = new FauxRequest();
$request->setIP( '10.20.30.40' );
$this->setSessionUser( $this->user, $request );
$this->assertFalse( $this->user->isAnon() );
$this->assertNull( $this->user->getBlock() );
}
public static function provideIsPingLimitable() {
yield 'Not ip excluded' => [ [], null, true ];
yield 'Ip excluded' => [ [ '1.2.3.4' ], null, false ];
yield 'Ip subnet excluded' => [ [ '1.2.3.0/8' ], null, false ];
yield 'noratelimit right' => [ [], 'noratelimit', false ];
}
/**
* @dataProvider provideIsPingLimitable
* @covers \MediaWiki\User\User::isPingLimitable
* @param array $rateLimitExcludeIps
* @param string|null $rightOverride
* @param bool $expected
*/
public function testIsPingLimitable(
array $rateLimitExcludeIps,
?string $rightOverride,
bool $expected
) {
$request = new FauxRequest();
$request->setIP( '1.2.3.4' );
$user = User::newFromSession( $request );
// We are trying to test for current user behaviour
// since we are interested in request IP
RequestContext::getMain()->setUser( $user );
$this->overrideConfigValue( MainConfigNames::RateLimitsExcludedIPs, $rateLimitExcludeIps );
if ( $rightOverride ) {
$this->overrideUserPermissions( $user, $rightOverride );
}
$this->assertSame( $expected, $user->isPingLimitable() );
}
public static function provideExperienceLevel() {
return [
[ 2, 2, 'newcomer' ],
[ 12, 3, 'newcomer' ],
[ 8, 5, 'newcomer' ],
[ 15, 10, 'learner' ],
[ 450, 20, 'learner' ],
[ 460, 33, 'learner' ],
[ 525, 28, 'learner' ],
[ 538, 33, 'experienced' ],
[ 9, null, 'newcomer' ],
[ 10, null, 'learner' ],
[ 501, null, 'experienced' ],
];
}
/**
* @covers \MediaWiki\User\User::getExperienceLevel
* @dataProvider provideExperienceLevel
*/
public function testExperienceLevel( $editCount, $memberSince, $expLevel ) {
$this->overrideConfigValues( [
MainConfigNames::LearnerEdits => 10,
MainConfigNames::LearnerMemberSince => 4,
MainConfigNames::ExperiencedUserEdits => 500,
MainConfigNames::ExperiencedUserMemberSince => 30,
] );
$db = $this->getDb();
$row = User::newQueryBuilder( $db )
->where( [ 'user_id' => $this->user->getId() ] )
->caller( __METHOD__ )
->fetchRow();
$row->user_editcount = $editCount;
if ( $memberSince !== null ) {
$row->user_registration = $db->timestamp( time() - $memberSince * 86400 );
} else {
$row->user_registration = null;
}
$user = User::newFromRow( $row );
$this->assertSame( $expLevel, $user->getExperienceLevel() );
}
/**
* @covers \MediaWiki\User\User::getExperienceLevel
*/
public function testExperienceLevelAnon() {
$user = User::newFromName( '10.11.12.13', false );
$this->assertFalse( $user->getExperienceLevel() );
}
public static function provideIsLocallyBlockedProxy() {
return [
[ '1.2.3.4', '1.2.3.4' ],
[ '1.2.3.4', '1.2.3.0/16' ],
];
}
/**
* @covers \MediaWiki\User\User::newFromId
*/
public function testNewFromId() {
$userId = $this->user->getId();
$this->assertGreaterThan(
0,
$userId,
'user has a working id'
);
$otherUser = User::newFromId( $userId );
$this->assertTrue(
$this->user->equals( $otherUser ),
'User created by id should match user with that id'
);
}
/**
* @covers \MediaWiki\User\User::newFromActorId
*/
public function testActorId() {
$this->filterDeprecated( '/Passing a parameter to getActorId\(\) is deprecated/', '1.36' );
// Newly-created user has an actor ID
$user = User::createNew( 'UserTestActorId1' );
$id = $user->getId();
$this->assertGreaterThan( 0, $user->getActorId(), 'User::createNew sets an actor ID' );
$user = User::newFromName( 'UserTestActorId2' );
$user->addToDatabase();
$this->assertGreaterThan( 0, $user->getActorId(), 'User::addToDatabase sets an actor ID' );
$user = User::newFromName( 'UserTestActorId1' );
$this->assertGreaterThan( 0, $user->getActorId(),
'Actor ID can be retrieved for user loaded by name' );
$user = User::newFromId( $id );
$this->assertGreaterThan( 0, $user->getActorId(),
'Actor ID can be retrieved for user loaded by ID' );
$user2 = User::newFromActorId( $user->getActorId() );
$this->assertSame( $user->getId(), $user2->getId(),
'User::newFromActorId works for an existing user' );
$row = User::newQueryBuilder( $this->getDb() )
->where( [ 'user_id' => $id ] )
->caller( __METHOD__ )
->fetchRow();
$user = User::newFromRow( $row );
$this->assertGreaterThan( 0, $user->getActorId(),
'Actor ID can be retrieved for user loaded with User::selectFields()' );
$user = User::newFromId( $id );
$user->setName( 'UserTestActorId4-renamed' );
$user->saveSettings();
$this->assertSame(
$user->getName(),
$this->getDb()->newSelectQueryBuilder()
->select( 'actor_name' )
->from( 'actor' )
->where( [ 'actor_id' => $user->getActorId() ] )
->caller( __METHOD__ )->fetchField(),
'User::saveSettings updates actor table for name change'
);
$ip = '192.168.12.34';
$this->getDb()->newDeleteQueryBuilder()
->deleteFrom( 'actor' )
->where( [ 'actor_name' => $ip ] )
->caller( __METHOD__ )
->execute();
// Next tests require disabling temp user feature.
$this->disableAutoCreateTempUser();
$user = User::newFromName( $ip, false );
$this->assertSame( 0, $user->getActorId(), 'Anonymous user has no actor ID by default' );
$this->filterDeprecated( '/Passing parameter of type IDatabase/' );
$this->assertGreaterThan( 0, $user->getActorId( $this->getDb() ),
'Actor ID can be created for an anonymous user' );
$user = User::newFromName( $ip, false );
$this->assertGreaterThan( 0, $user->getActorId(),
'Actor ID can be loaded for an anonymous user' );
$user2 = User::newFromActorId( $user->getActorId() );
$this->assertSame( $user->getName(), $user2->getName(),
'User::newFromActorId works for an anonymous user' );
}
/**
* @covers \MediaWiki\User\User::getActorId
*/
public function testForeignGetActorId() {
$this->filterDeprecated( '/Passing a parameter to getActorId\(\) is deprecated/', '1.36' );
$user = User::newFromName( 'UserTestActorId1' );
$this->expectException( PreconditionException::class );
$user->getActorId( 'Foreign Wiki' );
}
/**
* @covers \MediaWiki\User\User::getWikiId
*/
public function testGetWiki() {
$user = User::newFromName( 'UserTestActorId1' );
$this->assertSame( User::LOCAL, $user->getWikiId() );
}
/**
* @covers \MediaWiki\User\User::assertWiki
*/
public function testAssertWiki() {
$user = User::newFromName( 'UserTestActorId1' );
$user->assertWiki( User::LOCAL );
$this->assertTrue( true, 'User is for local wiki' );
$this->expectException( PreconditionException::class );
$user->assertWiki( 'Foreign Wiki' );
}
/**
* @covers \MediaWiki\User\User::newFromAnyId
*/
public function testNewFromAnyId() {
$this->disableAutoCreateTempUser();
// Registered user
$user = $this->user;
for ( $i = 1; $i <= 7; $i++ ) {
$test = User::newFromAnyId(
( $i & 1 ) ? $user->getId() : null,
( $i & 2 ) ? $user->getName() : null,
( $i & 4 ) ? $user->getActorId() : null
);
$this->assertSame( $user->getId(), $test->getId() );
$this->assertSame( $user->getName(), $test->getName() );
$this->assertSame( $user->getActorId(), $test->getActorId() );
}
// Anon user. Can't load by only user ID when that's 0.
$user = User::newFromName( '192.168.12.34', false );
// Make sure an actor ID exists
$this->getServiceContainer()->getActorNormalization()->acquireActorId( $user, $this->getDb() );
$test = User::newFromAnyId( null, '192.168.12.34', null );
$this->assertSame( $user->getId(), $test->getId() );
$this->assertSame( $user->getName(), $test->getName() );
$this->assertSame( $user->getActorId(), $test->getActorId() );
$test = User::newFromAnyId( null, null, $user->getActorId() );
$this->assertSame( $user->getId(), $test->getId() );
$this->assertSame( $user->getName(), $test->getName() );
$this->assertSame( $user->getActorId(), $test->getActorId() );
// Bogus data should still "work" as long as nothing triggers a ->load(),
// and accessing the specified data shouldn't do that.
$test = User::newFromAnyId( 123456, 'Bogus', 654321 );
$this->assertSame( 123456, $test->getId() );
$this->assertSame( 'Bogus', $test->getName() );
$this->assertSame( 654321, $test->getActorId() );
// Loading remote user by name from remote wiki should succeed
$test = User::newFromAnyId( null, 'Bogus', null, 'foo' );
$this->assertSame( 0, $test->getId() );
$this->assertSame( 'Bogus', $test->getName() );
$this->assertSame( 0, $test->getActorId() );
$test = User::newFromAnyId( 123456, 'Bogus', 654321, 'foo' );
$this->assertSame( 0, $test->getId() );
$this->assertSame( 0, $test->getActorId() );
// Exceptional cases
try {
User::newFromAnyId( null, null, null );
$this->fail( 'Expected exception not thrown' );
} catch ( InvalidArgumentException $ex ) {
}
try {
User::newFromAnyId( 0, null, 0 );
$this->fail( 'Expected exception not thrown' );
} catch ( InvalidArgumentException $ex ) {
}
// Loading remote user by id from remote wiki should fail
try {
User::newFromAnyId( 123456, null, 654321, 'foo' );
$this->fail( 'Expected exception not thrown' );
} catch ( InvalidArgumentException $ex ) {
}
}
/**
* @covers \MediaWiki\User\User::newFromIdentity
*/
public function testNewFromIdentity() {
// Registered user
$user = $this->user;
$this->assertSame( $user, User::newFromIdentity( $user ) );
// ID only
$identity = new UserIdentityValue( $user->getId(), '' );
$result = User::newFromIdentity( $identity );
$this->assertInstanceOf( User::class, $result );
$this->assertSame( $user->getId(), $result->getId(), 'ID' );
$this->assertSame( $user->getName(), $result->getName(), 'Name' );
$this->assertSame( $user->getActorId(), $result->getActorId(), 'Actor' );
// Name only
$identity = new UserIdentityValue( 0, $user->getName() );
$result = User::newFromIdentity( $identity );
$this->assertInstanceOf( User::class, $result );
$this->assertSame( $user->getId(), $result->getId(), 'ID' );
$this->assertSame( $user->getName(), $result->getName(), 'Name' );
$this->assertSame( $user->getActorId(), $result->getActorId(), 'Actor' );
}
/**
* @covers \MediaWiki\User\User::newFromConfirmationCode
*/
public function testNewFromConfirmationCode() {
$user = User::newFromConfirmationCode( 'NotARealConfirmationCode' );
$this->assertNull(
$user,
'Invalid confirmation codes result in null users when reading from replicas'
);
$user = User::newFromConfirmationCode( 'OtherFakeCode', IDBAccessObject::READ_LATEST );
$this->assertNull(
$user,
'Invalid confirmation codes result in null users when reading from master'
);
}
/**
* @covers \MediaWiki\User\User::newFromName
* @covers \MediaWiki\User\User::getName
* @covers \MediaWiki\User\User::getUserPage
* @covers \MediaWiki\User\User::getTalkPage
* @covers \MediaWiki\User\User::getTitleKey
* @covers \MediaWiki\User\User::whoIs
* @dataProvider provideNewFromName
*/
public function testNewFromName( $name, $titleKey ) {
$user = User::newFromName( $name );
$this->assertSame( $user->getName(), $name );
$this->assertEquals( $user->getUserPage(), Title::makeTitle( NS_USER, $name ) );
$this->assertEquals( $user->getTalkPage(), Title::makeTitle( NS_USER_TALK, $name ) );
$this->assertSame( $user->getTitleKey(), $titleKey );
$status = $user->addToDatabase();
$this->assertStatusOK( $status, 'User can be added to the database' );
$this->assertSame( $name, User::whoIs( $user->getId() ) );
}
public static function provideNewFromName() {
return [
[ 'Example1', 'Example1' ],
[ 'MediaWiki easter egg', 'MediaWiki_easter_egg' ],
[ 'See T22281 for more', 'See_T22281_for_more' ],
[ 'DannyS712', 'DannyS712' ],
];
}
/**
* @covers \MediaWiki\User\User::newFromName
*/
public function testNewFromName_extra() {
$user = User::newFromName( '1.2.3.4' );
$this->assertFalse( $user, 'IP addresses are not valid user names' );
$user = User::newFromName( 'DannyS712', true );
$otherUser = User::newFromName( 'DannyS712', 'valid' );
$this->assertTrue(
$user->equals( $otherUser ),
'true maps to valid for backwards compatibility'
);
}
/**
* @covers \MediaWiki\User\User::newFromSession
* @covers \MediaWiki\User\User::getRequest
*/
public function testSessionAndRequest() {
$req1 = new WebRequest;
$this->setRequest( $req1 );
$user = User::newFromSession();
$request = $user->getRequest();
$this->assertSame(
$req1,
$request,
'Creating a user without a request defaults to $wgRequest'
);
$req2 = new WebRequest;
$this->assertNotSame(
$req1,
$req2,
'passing a request that does not match $wgRequest'
);
$user = User::newFromSession( $req2 );
$request = $user->getRequest();
$this->assertSame(
$req2,
$request,
'Creating a user by passing a WebRequest successfully sets the request, ' .
'instead of using $wgRequest'
);
}
/**
* @covers \MediaWiki\User\User::newFromRow
* @covers \MediaWiki\User\User::loadFromRow
*/
public function testNewFromRow() {
// TODO: Create real tests here for loadFromRow
$row = (object)[];
$user = User::newFromRow( $row );
$this->assertInstanceOf( User::class, $user, 'newFromRow returns a user object' );
}
/**
* @covers \MediaWiki\User\User::newFromRow
* @covers \MediaWiki\User\User::loadFromRow
*/
public function testNewFromRow_bad() {
$this->expectException( InvalidArgumentException::class );
$this->expectExceptionMessage( '$row must be an object' );
User::newFromRow( [] );
}
/**
* @covers \MediaWiki\User\User::getBlock
* @covers \MediaWiki\User\User::isHidden
*/
public function testBlockInstanceCache() {
$this->hideDeprecated( User::class . '::isBlockedFrom' );
// First, check the user isn't blocked
$user = $this->getMutableTestUser()->getUser();
$ut = Title::makeTitle( NS_USER_TALK, $user->getName() );
$this->assertNull( $user->getBlock( false ) );
$this->assertFalse( $user->isHidden() );
// Block the user
$blocker = $this->getTestSysop()->getUser();
$block = new DatabaseBlock( [
'hideName' => true,
'allowUsertalk' => false,
'reason' => 'Because',
] );
$block->setTarget( $user );
$block->setBlocker( $blocker );
$blockStore = $this->getServiceContainer()->getDatabaseBlockStore();
$res = $blockStore->insertBlock( $block );
$this->assertTrue( (bool)$res['id'], 'Failed to insert block' );
// Clear cache and confirm it loaded the block properly
$user->clearInstanceCache();
$this->assertInstanceOf( DatabaseBlock::class, $user->getBlock( false ) );
$this->assertTrue( $user->isHidden() );
// Unblock
$blockStore->deleteBlock( $block );
// Clear cache and confirm it loaded the not-blocked properly
$user->clearInstanceCache();
$this->assertNull( $user->getBlock( false ) );
$this->assertFalse( $user->isHidden() );
}
/**
* @covers \MediaWiki\User\User::getBlock
*/
public function testCompositeBlocks() {
$user = $this->getMutableTestUser()->getUser();
$request = $user->getRequest();
$this->setSessionUser( $user, $request );
$blockStore = $this->getServiceContainer()->getDatabaseBlockStore();
$ipBlock = new DatabaseBlock( [
'address' => $user->getRequest()->getIP(),
'by' => $this->getTestSysop()->getUser(),
'createAccount' => true,
] );
$blockStore->insertBlock( $ipBlock );
$userBlock = new DatabaseBlock( [
'address' => $user,
'by' => $this->getTestSysop()->getUser(),
'createAccount' => false,
] );
$blockStore->insertBlock( $userBlock );
$block = $user->getBlock();
$this->assertInstanceOf( CompositeBlock::class, $block );
$this->assertTrue( $block->isCreateAccountBlocked() );
$this->assertTrue( $block->appliesToPasswordReset() );
$this->assertTrue( $block->appliesToNamespace( NS_MAIN ) );
}
/**
* @covers \MediaWiki\User\User::getBlock
*/
public function testUserBlock() {
$user = $this->getMutableTestUser()->getUser();
$request = $user->getRequest();
$this->setSessionUser( $user, $request );
$blockStore = $this->getServiceContainer()->getDatabaseBlockStore();
$ipBlock = new DatabaseBlock( [
'address' => $user,
'by' => $this->getTestSysop()->getUser(),
'createAccount' => true,
] );
$blockStore->insertBlock( $ipBlock );
$block = $user->getBlock();
$this->assertNotNull( $block, 'getuserBlock' );
$this->assertNotNull( $block->getTargetUserIdentity(), 'getTargetUserIdentity()' );
$this->assertSame( $user->getName(), $block->getTargetUserIdentity()->getName() );
}
public static function provideIsBlockedFrom() {
return [
'Sitewide block, basic operation' => [ 'Test page', true ],
'Sitewide block, not allowing user talk' => [
self::USER_TALK_PAGE, true, [
'allowUsertalk' => false,
]
],
'Sitewide block, allowing user talk' => [
self::USER_TALK_PAGE, false, [
'allowUsertalk' => true,
]
],
'Sitewide block, allowing user talk but $wgBlockAllowsUTEdit is false' => [
self::USER_TALK_PAGE, true, [
'allowUsertalk' => true,
'blockAllowsUTEdit' => false,
]
],
'Partial block, blocking the page' => [
'Test page', true, [
'pageRestrictions' => [ 'Test page' ],
]
],
'Partial block, not blocking the page' => [
'Test page 2', false, [
'pageRestrictions' => [ 'Test page' ],
]
],
'Partial block, not allowing user talk but user talk page is not blocked' => [
self::USER_TALK_PAGE, false, [
'allowUsertalk' => false,
'pageRestrictions' => [ 'Test page' ],
]
],
'Partial block, allowing user talk but user talk page is blocked' => [
self::USER_TALK_PAGE, true, [
'allowUsertalk' => true,
'pageRestrictions' => [ self::USER_TALK_PAGE ],
]
],
'Partial block, user talk page is not blocked but $wgBlockAllowsUTEdit is false' => [
self::USER_TALK_PAGE, false, [
'allowUsertalk' => false,
'pageRestrictions' => [ 'Test page' ],
'blockAllowsUTEdit' => false,
]
],
'Partial block, user talk page is blocked and $wgBlockAllowsUTEdit is false' => [
self::USER_TALK_PAGE, true, [
'allowUsertalk' => true,
'pageRestrictions' => [ self::USER_TALK_PAGE ],
'blockAllowsUTEdit' => false,
]
],
'Partial user talk namespace block, not allowing user talk' => [
self::USER_TALK_PAGE, true, [
'allowUsertalk' => false,
'namespaceRestrictions' => [ NS_USER_TALK ],
]
],
'Partial user talk namespace block, allowing user talk' => [
self::USER_TALK_PAGE, false, [
'allowUsertalk' => true,
'namespaceRestrictions' => [ NS_USER_TALK ],
]
],
'Partial user talk namespace block, where $wgBlockAllowsUTEdit is false' => [
self::USER_TALK_PAGE, true, [
'allowUsertalk' => true,
'namespaceRestrictions' => [ NS_USER_TALK ],
'blockAllowsUTEdit' => false,
]
],
];
}
/**
* @covers \MediaWiki\User\User::isBlockedFromEmailuser
* @covers \MediaWiki\User\User::isAllowedToCreateAccount
* @dataProvider provideIsBlockedFromAction
* @param bool $blockFromEmail Whether to block email access.
* @param bool $blockFromAccountCreation Whether to block account creation.
*/
public function testIsBlockedFromAction( $blockFromEmail, $blockFromAccountCreation ) {
$this->hideDeprecated( User::class . '::isBlockedFromEmailuser' );
$user = $this->getMutableTestUser( 'accountcreator' )->getUser();
$block = new DatabaseBlock( [
'expiry' => wfTimestamp( TS_MW, wfTimestamp() + ( 40 * 60 * 60 ) ),
'sitewide' => true,
'blockEmail' => $blockFromEmail,
'createAccount' => $blockFromAccountCreation
] );
$block->setTarget( $user );
$block->setBlocker( $this->getTestSysop()->getUser() );
$blockStore = $this->getServiceContainer()->getDatabaseBlockStore();
$blockStore->insertBlock( $block );
$this->assertSame( $blockFromEmail, $user->isBlockedFromEmailuser() );
$this->assertSame( !$blockFromAccountCreation, $user->isAllowedToCreateAccount() );
}
public static function provideIsBlockedFromAction() {
return [
'Block email access and account creation' => [ true, true ],
'Block only email access' => [ true, false ],
'Block only account creation' => [ false, true ],
'Allow email access and account creation' => [ false, false ],
];
}
/**
* @covers \MediaWiki\User\User::isBlockedFromUpload
* @dataProvider provideIsBlockedFromUpload
* @param bool $sitewide Whether to block sitewide.
* @param bool $expected Whether the user is expected to be blocked from uploads.
*/
public function testIsBlockedFromUpload( $sitewide, $expected ) {
$user = $this->getMutableTestUser()->getUser();
$block = new DatabaseBlock( [
'expiry' => wfTimestamp( TS_MW, wfTimestamp() + ( 40 * 60 * 60 ) ),
'sitewide' => $sitewide,
] );
$block->setTarget( $user );
$block->setBlocker( $this->getTestSysop()->getUser() );
$blockStore = $this->getServiceContainer()->getDatabaseBlockStore();
$blockStore->insertBlock( $block );
$this->assertSame( $expected, $user->isBlockedFromUpload() );
}
public static function provideIsBlockedFromUpload() {
return [
'sitewide blocks block uploads' => [ true, true ],
'partial blocks allow uploads' => [ false, false ],
];
}
/**
* @covers \MediaWiki\User\User::isSystemUser
*/
public function testIsSystemUser() {
$this->assertFalse( $this->user->isSystemUser(), 'Normal users are not system users' );
$user = User::newSystemUser( __METHOD__ );
$this->assertTrue( $user->isSystemUser(), 'Users created with newSystemUser() are system users' );
}
/**
* @covers \MediaWiki\User\User::newSystemUser
* @dataProvider provideNewSystemUser
* @param string $exists How/whether to create the user before calling User::newSystemUser
* - 'missing': Do not create the user
* - 'actor': Create an anonymous actor
* - 'user': Create a non-system user
* - 'system': Create a system user
* @param string $options Options to User::newSystemUser
* @param array $testOpts Test options
* @param string $expect 'user', 'exception', or 'null'
*/
public function testNewSystemUser( $exists, $options, $testOpts, $expect ) {
$this->filterDeprecated( '/User::newSystemUser options/' );
$origUser = null;
$actorId = null;
switch ( $exists ) {
case 'missing':
$name = 'TestNewSystemUser ' . TestUserRegistry::getNextId();
break;
case 'actor':
$name = 'TestNewSystemUser ' . TestUserRegistry::getNextId();
$this->getDb()->newInsertQueryBuilder()
->insertInto( 'actor' )
->row( [ 'actor_name' => $name ] )
->caller( __METHOD__ )
->execute();
$actorId = (int)$this->getDb()->insertId();
break;
case 'user':
$origUser = $this->getMutableTestUser()->getUser();
$name = $origUser->getName();
$actorId = $origUser->getActorId();
break;
case 'system':
$name = 'TestNewSystemUser ' . TestUserRegistry::getNextId();
$user = User::newSystemUser( $name ); // Heh.
$actorId = $user->getActorId();
// Use this hook as a proxy for detecting when a "steal" happens.
$this->setTemporaryHook( 'InvalidateEmailComplete', function () {
$this->fail( 'InvalidateEmailComplete hook should not have been called' );
} );
break;
}
$globals = $testOpts['globals'] ?? [];
if ( !empty( $testOpts['reserved'] ) ) {
$globals[MainConfigNames::ReservedUsernames] = [ $name ];
}
$this->overrideConfigValues( $globals );
$userNameUtils = $this->getServiceContainer()->getUserNameUtils();
$this->assertSame( empty( $testOpts['reserved'] ), $userNameUtils->isUsable( $name ) );
$this->assertTrue( $userNameUtils->isValid( $name ) );
if ( $expect === 'exception' ) {
// T248195: Duplicate entry errors will log the exception, don't fail because of that.
$this->setNullLogger( 'rdbms' );
$this->expectException( Exception::class );
}
$user = User::newSystemUser( $name, $options );
if ( $expect === 'null' ) {
$this->assertNull( $user );
if ( $origUser ) {
$this->assertNotSame(
User::INVALID_TOKEN, TestingAccessWrapper::newFromObject( $origUser )->mToken
);
$this->assertNotSame( '', $origUser->getEmail() );
$this->assertFalse( $origUser->isSystemUser(), 'Normal users should not be system users' );
}
} else {
$this->assertInstanceOf( User::class, $user );
$this->assertSame( $name, $user->getName() );
if ( $actorId !== null ) {
$this->assertSame( $actorId, $user->getActorId() );
}
$this->assertSame( User::INVALID_TOKEN, TestingAccessWrapper::newFromObject( $user )->mToken );
$this->assertSame( '', $user->getEmail() );
$this->assertTrue( $user->isSystemUser(), 'Newly created system users should be system users' );
}
}
public static function provideNewSystemUser() {
return [
'Basic creation' => [ 'missing', [], [], 'user' ],
'No creation' => [ 'missing', [ 'create' => false ], [], 'null' ],
'Validation fail' => [
'missing',
[ 'validate' => 'usable' ],
[ 'reserved' => true ],
'null'
],
'No stealing' => [ 'user', [], [], 'null' ],
'Stealing allowed' => [ 'user', [ 'steal' => true ], [], 'user' ],
'Stealing an already-system user' => [ 'system', [ 'steal' => true ], [], 'user' ],
'Anonymous actor (T236444)' => [ 'actor', [], [ 'reserved' => true ], 'user' ],
'System user (T236444), reserved' => [ 'system', [], [ 'reserved' => true ], 'user' ],
'Reserved but no anonymous actor' => [ 'missing', [], [ 'reserved' => true ], 'user' ],
'Anonymous actor but no creation' => [ 'actor', [ 'create' => false ], [], 'null' ],
'Anonymous actor but not reserved' => [ 'actor', [], [], 'exception' ],
];
}
/**
* @covers \MediaWiki\User\User::getName
* @covers \MediaWiki\User\User::setName
*/
public function testUserName() {
$user = User::newFromName( 'DannyS712' );
$this->assertSame(
'DannyS712',
$user->getName(),
'Santiy check: Users created using ::newFromName should return the name used'
);
$user->setName( 'FooBarBaz' );
$this->assertSame(
'FooBarBaz',
$user->getName(),
'Changing a username via ::setName should be reflected in ::getName'
);
}
/**
* @covers \MediaWiki\User\User::getEmail
* @covers \MediaWiki\User\User::setEmail
* @covers \MediaWiki\User\User::invalidateEmail
*/
public function testUserEmail() {
$user = $this->user;
$user->setEmail( 'TestEmail@mediawiki.org' );
$this->assertSame(
'TestEmail@mediawiki.org',
$user->getEmail(),
'Setting an email via ::setEmail should be reflected in ::getEmail'
);
$this->setTemporaryHook( 'UserSetEmail', function ( $user, &$email ) {
$this->fail(
'UserSetEmail hook should not be called when the new email ' .
'is the same as the old email.'
);
} );
$user->setEmail( 'TestEmail@mediawiki.org' );
$this->removeTemporaryHook( 'UserSetEmail' );
$this->setTemporaryHook( 'UserSetEmail', static function ( $user, &$email ) {
$email = 'SettingIntercepted@mediawiki.org';
} );
$user->setEmail( 'NewEmail@mediawiki.org' );
$this->assertSame(
'SettingIntercepted@mediawiki.org',
$user->getEmail(),
'Hooks can override setting email addresses'
);
$this->setTemporaryHook( 'UserGetEmail', static function ( $user, &$email ) {
$email = 'GettingIntercepted@mediawiki.org';
} );
$this->assertSame(
'GettingIntercepted@mediawiki.org',
$user->getEmail(),
'Hooks can override getting email address'
);
$this->removeTemporaryHook( 'UserGetEmail' );
$this->removeTemporaryHook( 'UserSetEmail' );
$user->invalidateEmail();
$this->assertSame(
'',
$user->getEmail(),
'After invalidation, a user email should be an empty string'
);
}
/**
* @covers \MediaWiki\User\User::setEmailWithConfirmation
*/
public function testSetEmailWithConfirmation_basic() {
$user = $this->getTestUser()->getUser();
$startingEmail = 'startingemail@mediawiki.org';
$user->setEmail( $startingEmail );
$this->overrideConfigValues( [
MainConfigNames::EnableEmail => false,
MainConfigNames::EmailAuthentication => false
] );
$status = $user->setEmailWithConfirmation( 'test1@mediawiki.org' );
$this->assertStatusError( 'emaildisabled', $status,
'Cannot set email when email is disabled'
);
$this->assertSame(
$user->getEmail(),
$startingEmail,
'Email has not changed'
);
$this->overrideConfigValue( MainConfigNames::EnableEmail, true );
$status = $user->setEmailWithConfirmation( $startingEmail );
$this->assertTrue(
$status->getValue(),
'Returns true if the email specified is the current email'
);
$this->assertSame(
$user->getEmail(),
$startingEmail,
'Email has not changed'
);
}
/**
* @covers \MediaWiki\User\User::isItemLoaded
* @covers \MediaWiki\User\User::setItemLoaded
*/
public function testItemLoaded() {
$user = User::newFromName( 'DannyS712' );
$this->assertTrue(
$user->isItemLoaded( 'name', 'only' ),
'Users created by name have user names loaded'
);
$this->assertFalse(
$user->isItemLoaded( 'all', 'all' ),
'Not everything is loaded yet'
);
$user->load();
$this->assertTrue(
$user->isItemLoaded( 'FooBar', 'all' ),
'All items now loaded'
);
}
/**
* @covers \MediaWiki\User\User::requiresHTTPS
* @dataProvider provideRequiresHTTPS
*/
public function testRequiresHTTPS( $preference, bool $expected ) {
$this->overrideConfigValues( [
MainConfigNames::SecureLogin => true,
MainConfigNames::ForceHTTPS => false,
] );
$user = User::newFromName( 'UserWhoMayRequireHTTPS' );
$user->addToDatabase();
$this->getServiceContainer()->getUserOptionsManager()->setOption(
$user,
'prefershttps',
$preference
);
$user->saveSettings();
$this->assertTrue( $user->isRegistered() );
$this->assertSame( $expected, $user->requiresHTTPS() );
}
public static function provideRequiresHTTPS() {
return [
'Wants, requires' => [ true, true ],
'Does not want, not required' => [ false, false ],
];
}
/**
* @covers \MediaWiki\User\User::requiresHTTPS
*/
public function testRequiresHTTPS_disabled() {
$this->overrideConfigValues( [
MainConfigNames::SecureLogin => false,
MainConfigNames::ForceHTTPS => false,
] );
$user = User::newFromName( 'UserWhoMayRequireHTTP' );
$user->addToDatabase();
$this->getServiceContainer()->getUserOptionsManager()->setOption(
$user,
'prefershttps',
true
);
$user->saveSettings();
$this->assertTrue( $user->isRegistered() );
$this->assertFalse(
$user->requiresHTTPS(),
'User preference ignored if wgSecureLogin is false'
);
}
/**
* @covers \MediaWiki\User\User::requiresHTTPS
*/
public function testRequiresHTTPS_forced() {
$this->overrideConfigValues( [
MainConfigNames::SecureLogin => true,
MainConfigNames::ForceHTTPS => true,
] );
$user = User::newFromName( 'UserWhoMayRequireHTTP' );
$user->addToDatabase();
$this->getServiceContainer()->getUserOptionsManager()->setOption(
$user,
'prefershttps',
false
);
$user->saveSettings();
$this->assertTrue( $user->isRegistered() );
$this->assertTrue(
$user->requiresHTTPS(),
'User preference ignored if wgForceHTTPS is true'
);
}
/**
* @covers \MediaWiki\User\User::addToDatabase
*/
public function testAddToDatabase_bad() {
$user = new User();
$this->expectException( RuntimeException::class );
$this->expectExceptionMessage(
'User name field is not set.'
);
$user->addToDatabase();
}
/**
* @covers \MediaWiki\User\User::pingLimiter
*/
public function testPingLimiter() {
$user = $this->getTestUser()->getUser();
$limiter = $this->createNoOpMock( RateLimiter::class, [ 'limit', 'isLimitable' ] );
$limiter->method( 'isLimitable' )->willReturn( true );
$limiter->method( 'limit' )->willReturnCallback(
function ( RateLimitSubject $subject, $action ) use ( $user ) {
$this->assertSame( $user, $subject->getUser() );
return $action === 'limited';
}
);
$this->setService( 'RateLimiter', $limiter );
$this->assertTrue( $user->pingLimiter( 'limited' ) );
$this->assertFalse( $user->pingLimiter( 'unlimited' ) );
}
/**
* @covers \MediaWiki\User\User::loadFromDatabase
* @covers \MediaWiki\User\User::loadDefaults
*/
public function testBadUserID() {
$user = User::newFromId( 999999999 );
$this->assertSame( 'Unknown user', $user->getName() );
}
/**
* @covers \MediaWiki\User\User::probablyCan
* @covers \MediaWiki\User\User::definitelyCan
* @covers \MediaWiki\User\User::authorizeRead
* @covers \MediaWiki\User\User::authorizeWrite
*/
public function testAuthorityMethods() {
$user = $this->getTestUser()->getUser();
$page = Title::makeTitle( NS_MAIN, 'Test' );
$this->assertFalse( $user->probablyCan( 'create', $page ) );
$this->assertFalse( $user->definitelyCan( 'create', $page ) );
$this->assertFalse( $user->authorizeRead( 'create', $page ) );
$this->assertFalse( $user->authorizeWrite( 'create', $page ) );
$this->overrideUserPermissions( $user, 'createpage' );
$this->assertTrue( $user->probablyCan( 'create', $page ) );
$this->assertTrue( $user->definitelyCan( 'create', $page ) );
$this->assertTrue( $user->authorizeRead( 'create', $page ) );
$this->assertTrue( $user->authorizeWrite( 'create', $page ) );
}
/**
* @covers \MediaWiki\User\User::isAllowed
* @covers \MediaWiki\User\User::__sleep
*/
public function testSerializationRoudTripWithAuthority() {
$user = $this->getTestUser()->getUser();
$isAllowed = $user->isAllowed( 'read' ); // Memoize the Authority
$unserializedUser = unserialize( serialize( $user ) );
$this->assertSame( $user->getId(), $unserializedUser->getId() );
$this->assertSame( $isAllowed, $unserializedUser->isAllowed( 'read' ) );
}
public static function provideIsTemp() {
return [
[ '~2024-1', true ],
[ '~1', true ],
[ 'Some user', false ],
];
}
/**
* @covers \MediaWiki\User\User::isTemp
* @dataProvider provideIsTemp
*/
public function testIsTemp( $name, $expected ) {
$this->enableAutoCreateTempUser();
$user = new User;
$user->setName( $name );
$this->assertSame( $expected, $user->isTemp() );
}
/**
* @covers \MediaWiki\User\User::isTemp
*/
public function testSetIsTempInLoadDefaults() {
$this->enableAutoCreateTempUser();
$user = new User();
$user->loadDefaults();
$this->assertSame( false, $user->isTemp() );
$user->loadDefaults( '~2024-1' );
$this->assertSame( true, $user->isTemp() );
}
/**
* @covers \MediaWiki\User\User::isNamed
*/
public function testIsNamed() {
$this->enableAutoCreateTempUser();
// Temp user is not named
$user = new User;
$user->setName( '~1' );
$this->assertFalse( $user->isNamed() );
// Registered user is named
$user = $this->getMutableTestUser()->getUser();
$this->assertTrue( $user->isNamed() );
// Anon is not named
$user = new User;
$this->assertFalse( $user->isNamed() );
}
public static function provideAddToDatabase_temp() {
return [
[ '~1', '1' ],
[ 'Some user', '0' ]
];
}
/**
* @covers \MediaWiki\User\User::addToDatabase
* @dataProvider provideAddToDatabase_temp
*/
public function testAddToDatabase_temp( $name, $expected ) {
$this->enableAutoCreateTempUser();
$user = User::newFromName( $name );
$user->addToDatabase();
$field = $this->getDb()->newSelectQueryBuilder()
->select( 'user_is_temp' )
->from( 'user' )
->where( [ 'user_name' => $name ] )
->caller( __METHOD__ )
->fetchField();
$this->assertSame( $expected, $field );
}
/**
* @covers \MediaWiki\User\User::spreadAnyEditBlock
* @covers \MediaWiki\User\User::spreadBlock
*/
public function testSpreadAnyEditBlockForAnonUser() {
$hookCalled = false;
$this->setTemporaryHook( 'SpreadAnyEditBlock', static function () use ( &$hookCalled ){
$hookCalled = true;
} );
$user = new User;
$user->setName( '1.2.3.4' );
$user->spreadAnyEditBlock();
$this->assertFalse( $hookCalled );
}
/**
* @covers \MediaWiki\User\User::spreadAnyEditBlock
* @covers \MediaWiki\User\User::spreadBlock
* @dataProvider provideBlockWasSpreadValues
*/
public function testSpreadAnyEditBlockForUnblockedUser( $mockBlockWasSpreadHookValue ) {
// Assert that the SpreadAnyEditBlock hook gets called with the right arguments when
// ::spreadAnyEditBlock is called for a registered user.
$hookCalled = false;
$this->setTemporaryHook(
'SpreadAnyEditBlock',
function ( $user, &$blockWasSpread ) use ( &$hookCalled, $mockBlockWasSpreadHookValue ) {
$hookCalled = true;
$blockWasSpread = $mockBlockWasSpreadHookValue;
$this->assertSame( $this->user, $user );
}
);
$this->assertSame( $mockBlockWasSpreadHookValue, $this->user->spreadAnyEditBlock() );
$this->assertTrue( $hookCalled );
}
public static function provideBlockWasSpreadValues() {
return [
'SpreadAnyEditBlock hook handler sets $blockWasSpread to true' => [ true ],
'No SpreadAnyEditBlock hook handler spread a block' => [ false ],
];
}
/**
* @covers \MediaWiki\User\User::spreadAnyEditBlock
* @covers \MediaWiki\User\User::spreadBlock
*/
public function testSpreadAnyEditBlockForBlockedUser() {
$this->getServiceContainer()->getBlockUserFactory()->newBlockUser(
$this->user, $this->getTestSysop()->getAuthority(), 'indefinite', '', [ 'isAutoblocking' => true ]
)->placeBlockUnsafe();
RequestContext::getMain()->getRequest()->setIP( '1.2.3.4' );
$this->assertTrue( $this->user->spreadAnyEditBlock() );
$this->assertNotNull( $this->getServiceContainer()->getBlockManager()->getIpBlock( '1.2.3.4', true ) );
}
}
PK ! !> pU U user/UserEditTrackerTest.phpnu Iw getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
if ( !$page->exists() ) {
$page->insertOn( $this->getDb() );
}
$rev = new MutableRevisionRecord( $title );
$rev->setContent( SlotRecord::MAIN, new WikitextContent( $timestamp ) );
$rev->setComment( CommentStoreComment::newUnsavedComment( '' ) );
$rev->setTimestamp( $timestamp );
$rev->setUser( $user );
$rev->setPageId( $page->getId() );
$this->getServiceContainer()->getRevisionStore()->insertRevisionOn( $rev, $this->getDb() );
}
/**
* Change the user_editcount field in the DB
*
* @param UserIdentity $user
* @param int|null $count
*/
private function setDbEditCount( $user, $count ) {
$this->getDb()->newUpdateQueryBuilder()
->update( 'user' )
->set( [ 'user_editcount' => $count ] )
->where( [ 'user_id' => $user->getId() ] )
->caller( __METHOD__ )
->execute();
}
public function testGetUserEditCount() {
// Set user_editcount to 5
$user = $this->getMutableTestUser()->getUser();
$update = new UserEditCountUpdate( $user, 5 );
$update->doUpdate();
$tracker = $this->getServiceContainer()->getUserEditTracker();
$this->assertSame( 5, $tracker->getUserEditCount( $user ) );
// Now fetch from cache
$this->assertSame( 5, $tracker->getUserEditCount( $user ) );
}
public function testGetUserEditCount_anon() {
// getUserEditCount returns null if the user is unregistered
$anon = UserIdentityValue::newAnonymous( '1.2.3.4' );
$tracker = $this->getServiceContainer()->getUserEditTracker();
$this->assertNull( $tracker->getUserEditCount( $anon ) );
}
public function testGetUserEditCount_null() {
// getUserEditCount doesn't find a value in user_editcount and calls
// initializeUserEditCount
$user = $this->getMutableTestUser()->getUserIdentity();
$this->setDbEditCount( $user, null );
$tracker = $this->getServiceContainer()->getUserEditTracker();
$this->assertSame( 0, $tracker->getUserEditCount( $user ) );
}
public function testInitializeUserEditCount() {
$user = $this->getMutableTestUser()->getUser();
$this->editTrackerDoEdit( $user, '20200101000000' );
$tracker = $this->getServiceContainer()->getUserEditTracker();
$tracker->initializeUserEditCount( $user );
$this->runJobs();
$this->assertSame( 1, $tracker->getUserEditCount( $user ) );
}
public function testGetEditTimestamp() {
$user = $this->getMutableTestUser()->getUser();
$tracker = $this->getServiceContainer()->getUserEditTracker();
$this->assertFalse( $tracker->getFirstEditTimestamp( $user ) );
$this->assertFalse( $tracker->getLatestEditTimestamp( $user ) );
$ts1 = '20010101000000';
$ts2 = '20020101000000';
$ts3 = '20030101000000';
$this->editTrackerDoEdit( $user, $ts3 );
$this->editTrackerDoEdit( $user, $ts2 );
$this->editTrackerDoEdit( $user, $ts1 );
$this->assertSame( $ts1, $tracker->getFirstEditTimestamp( $user ) );
$this->assertSame( $ts3, $tracker->getLatestEditTimestamp( $user ) );
}
public function testGetEditTimestamp_anon() {
$this->disableAutoCreateTempUser();
$user = $this->getServiceContainer()->getUserFactory()
->newFromName( '127.0.0.1', UserRigorOptions::RIGOR_NONE );
$tracker = $this->getServiceContainer()->getUserEditTracker();
$this->editTrackerDoEdit( $user, '20200101000000' );
$this->assertFalse( $tracker->getFirstEditTimestamp( $user ) );
$this->assertFalse( $tracker->getLatestEditTimestamp( $user ) );
}
public function testClearUserEditCache() {
$user = $this->getMutableTestUser()->getUser();
$tracker = $this->getServiceContainer()->getUserEditTracker();
$this->assertSame( 0, $tracker->getUserEditCount( $user ) );
$this->setDbEditCount( $user, 1 );
$this->assertSame( 0, $tracker->getUserEditCount( $user ) );
$tracker->clearUserEditCache( $user );
$this->assertSame( 1, $tracker->getUserEditCount( $user ) );
}
public function testIncrementUserEditCount() {
$tracker = $this->getServiceContainer()->getUserEditTracker();
$user = $this->getMutableTestUser()->getUser();
$editCountStart = $tracker->getUserEditCount( $user );
$this->getDb()->startAtomic( __METHOD__ ); // let deferred updates queue up
$tracker->incrementUserEditCount( $user );
$this->assertSame(
1,
DeferredUpdates::pendingUpdatesCount(),
'Update queued for registered user'
);
$tracker->incrementUserEditCount( UserIdentityValue::newAnonymous( '1.1.1.1' ) );
$this->assertSame(
1,
DeferredUpdates::pendingUpdatesCount(),
'No update queued for anonymous user'
);
$this->getDb()->endAtomic( __METHOD__ ); // run deferred updates
$this->assertSame(
0,
DeferredUpdates::pendingUpdatesCount(),
'deferred updates ran'
);
$editCountEnd = $tracker->getUserEditCount( $user );
$this->assertSame(
1,
$editCountEnd - $editCountStart,
'Edit count was incremented'
);
}
public function testManualCache() {
// Make sure manually setting the cached value overrides the database, in case
// User::loadFromRow() is called with a row containing user_editcount that is
// different from the actual database value, the row takes precedence
$user = new UserIdentityValue( 123, __METHOD__ );
$this->setDbEditCount( $user, 5 );
$tracker = $this->getServiceContainer()->getUserEditTracker();
$tracker->setCachedUserEditCount( $user, 10 );
$this->assertSame( 10, $tracker->getUserEditCount( $user ) );
}
}
PK ! nR&S &S user/PasswordResetTest.phpnu Iw makeConfig( $enableEmail, $passwordResetRoutes );
$authManager = $this->createMock( AuthManager::class );
$authManager->method( 'allowsAuthenticationDataChange' )
->willReturn( $allowsAuthenticationDataChange ? Status::newGood() : Status::newFatal( 'foo' ) );
$user = $this->createMock( User::class );
$user->method( 'getName' )->willReturn( 'Foo' );
$user->method( 'getBlock' )->willReturn( $block );
$user->method( 'isAllowed' )->with( 'editmyprivateinfo' )->willReturn( $canEditPrivate );
$passwordReset = new PasswordReset(
$config,
new NullLogger(),
$authManager,
$this->createHookContainer(),
$this->createNoOpMock( UserIdentityLookup::class ),
$this->createNoOpMock( UserFactory::class ),
$this->createNoOpMock( UserNameUtils::class ),
$this->createNoOpMock( UserOptionsLookup::class )
);
$this->assertSame( $isAllowed, $passwordReset->isAllowed( $user )->isGood() );
}
public static function provideIsAllowed() {
return [
'no routes' => [
'passwordResetRoutes' => [],
'enableEmail' => true,
'allowsAuthenticationDataChange' => true,
'canEditPrivate' => true,
'block' => null,
'isAllowed' => false,
],
'email disabled' => [
'passwordResetRoutes' => [ 'username' => true ],
'enableEmail' => false,
'allowsAuthenticationDataChange' => true,
'canEditPrivate' => true,
'block' => null,
'isAllowed' => false,
],
'auth data change disabled' => [
'passwordResetRoutes' => [ 'username' => true ],
'enableEmail' => true,
'allowsAuthenticationDataChange' => false,
'canEditPrivate' => true,
'block' => null,
'isAllowed' => false,
],
'cannot edit private data' => [
'passwordResetRoutes' => [ 'username' => true ],
'enableEmail' => true,
'allowsAuthenticationDataChange' => true,
'canEditPrivate' => false,
'block' => null,
'isAllowed' => false,
],
'blocked with account creation disabled' => [
'passwordResetRoutes' => [ 'username' => true ],
'enableEmail' => true,
'allowsAuthenticationDataChange' => true,
'canEditPrivate' => true,
'block' => new DatabaseBlock( [ 'createAccount' => true ] ),
'isAllowed' => false,
],
'blocked w/o account creation disabled' => [
'passwordResetRoutes' => [ 'username' => true ],
'enableEmail' => true,
'allowsAuthenticationDataChange' => true,
'canEditPrivate' => true,
'block' => new DatabaseBlock( [] ),
'isAllowed' => true,
],
'using blocked proxy' => [
'passwordResetRoutes' => [ 'username' => true ],
'enableEmail' => true,
'allowsAuthenticationDataChange' => true,
'canEditPrivate' => true,
'block' => new SystemBlock(
[ 'systemBlock' => 'proxy' ]
),
'isAllowed' => false,
],
'globally blocked with account creation not disabled' => [
'passwordResetRoutes' => [ 'username' => true ],
'enableEmail' => true,
'allowsAuthenticationDataChange' => true,
'canEditPrivate' => true,
'block' => null,
'isAllowed' => true,
],
'blocked via wgSoftBlockRanges' => [
'passwordResetRoutes' => [ 'username' => true ],
'enableEmail' => true,
'allowsAuthenticationDataChange' => true,
'canEditPrivate' => true,
'block' => new SystemBlock(
[ 'systemBlock' => 'wgSoftBlockRanges', 'anonOnly' => true ]
),
'isAllowed' => true,
],
'blocked with an unknown system block type' => [
'passwordResetRoutes' => [ 'username' => true ],
'enableEmail' => true,
'allowsAuthenticationDataChange' => true,
'canEditPrivate' => true,
'block' => new SystemBlock( [ 'systemBlock' => 'unknown' ] ),
'isAllowed' => false,
],
'blocked with multiple blocks, all allowing password reset' => [
'passwordResetRoutes' => [ 'username' => true ],
'enableEmail' => true,
'allowsAuthenticationDataChange' => true,
'canEditPrivate' => true,
'block' => new CompositeBlock( [
'originalBlocks' => [
new SystemBlock( [ 'systemBlock' => 'wgSoftBlockRanges', 'anonOnly' => true ] ),
new DatabaseBlock( [] ),
]
] ),
'isAllowed' => true,
],
'blocked with multiple blocks, not all allowing password reset' => [
'passwordResetRoutes' => [ 'username' => true ],
'enableEmail' => true,
'allowsAuthenticationDataChange' => true,
'canEditPrivate' => true,
'block' => new CompositeBlock( [
'originalBlocks' => [
new SystemBlock( [ 'systemBlock' => 'wgSoftBlockRanges', 'anonOnly' => true ] ),
new SystemBlock( [ 'systemBlock' => 'proxy' ] ),
]
] ),
'isAllowed' => false,
],
'all OK' => [
'passwordResetRoutes' => [ 'username' => true ],
'enableEmail' => true,
'allowsAuthenticationDataChange' => true,
'canEditPrivate' => true,
'block' => null,
'isAllowed' => true,
],
];
}
public function testExecute_notAllowed() {
$user = $this->createMock( User::class );
/** @var User $user */
$passwordReset = $this->getMockBuilder( PasswordReset::class )
->disableOriginalConstructor()
->onlyMethods( [ 'isAllowed' ] )
->getMock();
$passwordReset->method( 'isAllowed' )
->with( $user )
->willReturn( Status::newFatal( 'somestatuscode' ) );
/** @var PasswordReset $passwordReset */
$this->expectException( LogicException::class );
$passwordReset->execute( $user );
}
/**
* @dataProvider provideExecute
* @param string|bool $expectedError
* @param ServiceOptions $config
* @param User $performingUser
* @param AuthManager $authManager
* @param string|null $username
* @param string|null $email
* @param User[] $usersWithEmail
* @covers \MediaWiki\Deferred\SendPasswordResetEmailUpdate
*/
public function testExecute(
$expectedError,
ServiceOptions $config,
User $performingUser,
AuthManager $authManager,
$username = '',
$email = '',
array $usersWithEmail = []
) {
$users = $this->makeUsers();
// Only User1 has `requireemail` true, everything else false (so that is the default)
$userOptionsLookup = new StaticUserOptionsLookup(
[ 'User1' => [ 'requireemail' => true ] ],
[ 'requireemail' => false ]
);
// Similar to $lookupUser callback, but with null instead of false
$userFactory = $this->createMock( UserFactory::class );
$userFactory->method( 'newFromName' )
->willReturnCallback(
static function ( $username ) use ( $users ) {
return $users[ $username ] ?? null;
}
);
$userIdentityLookup = $this->createMock( UserIdentityLookup::class );
$userFactory->method( 'newFromUserIdentity' )
->willReturnArgument( 0 );
$lookupUser = static function ( $username ) use ( $users ) {
return $users[ $username ] ?? false;
};
$passwordReset = $this->getMockBuilder( PasswordReset::class )
->onlyMethods( [ 'getUsersByEmail', 'isAllowed' ] )
->setConstructorArgs( [
$config,
new NullLogger(),
$authManager,
$this->createHookContainer(),
$userIdentityLookup,
$userFactory,
$this->getDummyUserNameUtils(),
$userOptionsLookup
] )
->getMock();
$passwordReset->method( 'getUsersByEmail' )->with( $email )
->willReturn( array_map( $lookupUser, $usersWithEmail ) );
$passwordReset->method( 'isAllowed' )
->willReturn( Status::newGood() );
/** @var PasswordReset $passwordReset */
$status = $passwordReset->execute( $performingUser, $username, $email );
if ( is_string( $expectedError ) ) {
$this->assertStatusError( $expectedError, $status );
} elseif ( $expectedError ) {
$this->assertStatusNotOk( $status );
} else {
$this->assertStatusGood( $status );
}
}
public function provideExecute() {
// 'User1' has the 'requireemail' preference set (see testExecute()). Other users do not.
$defaultConfig = $this->makeConfig( true, [ 'username' => true, 'email' => true ] );
$performingUser = $this->makePerformingUser( self::VALID_IP, false );
$throttledUser = $this->makePerformingUser( self::VALID_IP, true );
return [
'Throttled, pretend everything is ok' => [
'expectedError' => false,
'config' => $defaultConfig,
'performingUser' => $throttledUser,
'authManager' => $this->makeAuthManager(),
'username' => 'User1',
'email' => '',
'usersWithEmail' => [],
],
'Throttled, email required for resets, is invalid, pretend everything is ok' => [
'expectedError' => false,
'config' => $defaultConfig,
'performingUser' => $throttledUser,
'authManager' => $this->makeAuthManager(),
'username' => 'User1',
'email' => '[invalid email]',
'usersWithEmail' => [],
],
'Invalid email' => [
'expectedError' => 'passwordreset-invalidemail',
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager(),
'username' => '',
'email' => '[invalid email]',
'usersWithEmail' => [],
],
'No username, no email' => [
'expectedError' => 'passwordreset-nodata',
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager(),
'username' => '',
'email' => '',
'usersWithEmail' => [],
],
'Email route not enabled' => [
'expectedError' => 'passwordreset-nodata',
'config' => $this->makeConfig( true, [ 'username' => true ] ),
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager(),
'username' => '',
'email' => self::VALID_EMAIL,
'usersWithEmail' => [],
],
'Username route not enabled' => [
'expectedError' => 'passwordreset-nodata',
'config' => $this->makeConfig( true, [ 'email' => true ] ),
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager(),
'username' => 'User1',
'email' => '',
'usersWithEmail' => [],
],
'No routes enabled' => [
'expectedError' => 'passwordreset-nodata',
'config' => $this->makeConfig( true, [] ),
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager(),
'username' => 'User1',
'email' => self::VALID_EMAIL,
'usersWithEmail' => [],
],
'Email required for resets but is empty, pretend everything is OK' => [
'expectedError' => false,
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager(),
'username' => 'User1',
'email' => '',
'usersWithEmail' => [],
],
'Email required for resets but is invalid' => [
'expectedError' => 'passwordreset-invalidemail',
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager(),
'username' => 'User1',
'email' => '[invalid email]',
'usersWithEmail' => [],
],
'Password email already sent within 24 hours, pretend everything is ok' => [
'expectedError' => false,
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager( [ 'User1' ], 0, [], [ 'User1' ] ),
'username' => 'User1',
'email' => '',
'usersWithEmail' => [ 'User1' ],
],
'No user by this username, pretend everything is OK' => [
'expectedError' => false,
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager(),
'username' => 'Nonexistent user',
'email' => '',
'usersWithEmail' => [],
],
'Username is not valid' => [
'expectedError' => 'noname',
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager(),
'username' => 'Invalid|username',
'email' => '',
'usersWithEmail' => [],
],
'If no users with this email found, pretend everything is OK' => [
'expectedError' => false,
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager(),
'username' => '',
'email' => 'some@not.found.email',
'usersWithEmail' => [],
],
'No email for the user, pretend everything is OK' => [
'expectedError' => false,
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager(),
'username' => 'BadUser',
'email' => '',
'usersWithEmail' => [],
],
'Email required for resets, no match' => [
'expectedError' => false,
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager(),
'username' => 'User1',
'email' => 'some@other.email',
'usersWithEmail' => [],
],
"Couldn't determine the performing user's IP" => [
'expectedError' => 'badipaddress',
'config' => $defaultConfig,
'performingUser' => $this->makePerformingUser( '', false ),
'authManager' => $this->makeAuthManager(),
'username' => 'User1',
'email' => '',
'usersWithEmail' => [],
],
'User is allowed, but ignored' => [
'expectedError' => 'passwordreset-ignored',
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager( [ 'User2' ], 0, [ 'User2' ] ),
'username' => 'User2',
'email' => '',
'usersWithEmail' => [],
],
'One of users is ignored' => [
'expectedError' => 'passwordreset-ignored',
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager( [ 'User1', 'User2' ], 0, [ 'User2' ] ),
'username' => '',
'email' => self::VALID_EMAIL,
'usersWithEmail' => [ 'User1', 'User2' ],
],
'User is rejected' => [
'expectedError' => 'rejected by test mock',
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager(),
'username' => 'User2',
'email' => '',
'usersWithEmail' => [],
],
'One of users is rejected' => [
'expectedError' => 'rejected by test mock',
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager( [ 'User1' ] ),
'username' => '',
'email' => self::VALID_EMAIL,
'usersWithEmail' => [ 'User1', 'User2' ],
],
'Reset one user via password' => [
'expectedError' => false,
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager( [ 'User1' ], 1 ),
'username' => 'User1',
'email' => self::VALID_EMAIL,
// Make sure that only the user specified by username is reset
'usersWithEmail' => [ 'User1', 'User2' ],
],
'Reset one user via email' => [
'expectedError' => false,
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager( [ 'User2' ], 1 ),
'username' => '',
'email' => self::VALID_EMAIL,
'usersWithEmail' => [ 'User2' ],
],
'Reset multiple users via email' => [
'expectedError' => false,
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager( [ 'User2', 'User3' ], 2 ),
'username' => '',
'email' => self::VALID_EMAIL,
'usersWithEmail' => [ 'User2', 'User3' ],
],
"Email is not required for resets, this user didn't opt in" => [
'expectedError' => false,
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager( [ 'User2' ], 1 ),
'username' => 'User2',
'email' => self::VALID_EMAIL,
'usersWithEmail' => [ 'User2' ],
],
'Reset three users via email that did not opt in, multiple users with same email' => [
'expectedError' => false,
'config' => $defaultConfig,
'performingUser' => $performingUser,
'authManager' => $this->makeAuthManager( [ 'User2', 'User3', 'User4' ], 3, [ 'User1' ] ),
'username' => '',
'email' => self::VALID_EMAIL,
'usersWithEmail' => [ 'User1', 'User2', 'User3', 'User4' ],
],
];
}
private function makeConfig( $enableEmail, array $passwordResetRoutes ) {
$hash = [
MainConfigNames::EnableEmail => $enableEmail,
MainConfigNames::PasswordResetRoutes => $passwordResetRoutes,
];
return new ServiceOptions( PasswordReset::CONSTRUCTOR_OPTIONS, $hash );
}
/**
* @param string $ip
* @param bool $pingLimited
* @return User
*/
private function makePerformingUser( string $ip, $pingLimited ): User {
$request = $this->createMock( WebRequest::class );
$request->method( 'getIP' )
->willReturn( $ip );
/** @var WebRequest $request */
$user = $this->getMockBuilder( User::class )
->onlyMethods( [ 'getName', 'pingLimiter', 'getRequest', 'isAllowed' ] )
->getMock();
$user->method( 'getName' )
->willReturn( 'SomeUser' );
$user->method( 'pingLimiter' )
->with( 'mailpassword' )
->willReturn( $pingLimited );
$user->method( 'getRequest' )
->willReturn( $request );
// Always has the relevant rights, just checking based on rate limits
$user->method( 'isAllowed' )->with( 'editmyprivateinfo' )->willReturn( true );
/** @var User $user */
return $user;
}
/**
* @param string[] $allowed Usernames that are allowed to send password reset email
* by AuthManager's allowsAuthenticationDataChange method.
* @param int $numUsersToAuth Number of users that will receive email
* @param string[] $ignored Usernames that are allowed but ignored by AuthManager's
* allowsAuthenticationDataChange method and will not receive password reset email.
* @param string[] $mailThrottledLimited Usernames that have already
* received the password reset email within a given time, and AuthManager
* changeAuthenticationData method will mark them as 'throttled-mailpassword.'
* @return AuthManager
*/
private function makeAuthManager(
array $allowed = [],
$numUsersToAuth = 0,
array $ignored = [],
array $mailThrottledLimited = []
): AuthManager {
$authManager = $this->createMock( AuthManager::class );
$authManager->method( 'allowsAuthenticationDataChange' )
->willReturnCallback(
static function ( TemporaryPasswordAuthenticationRequest $req )
use ( $allowed, $ignored, $mailThrottledLimited ) {
if ( in_array( $req->username, $mailThrottledLimited, true ) ) {
return Status::newGood( 'throttled-mailpassword' );
}
$value = in_array( $req->username, $ignored, true )
? 'ignored'
: 'okie dokie';
return in_array( $req->username, $allowed, true )
? Status::newGood( $value )
: Status::newFatal( 'rejected by test mock' );
} );
// changeAuthenticationData is executed in the deferred update class
// SendPasswordResetEmailUpdate
$authManager->expects( $this->exactly( $numUsersToAuth ) )
->method( 'changeAuthenticationData' );
/** @var AuthManager $authManager */
return $authManager;
}
/**
* @return User[]
*/
private function makeUsers() {
$getGoodUserCb = function ( int $num ) {
$user = $this->createMock( User::class );
$user->method( 'getName' )->willReturn( "User$num" );
$user->method( 'getId' )->willReturn( $num );
$user->method( 'isRegistered' )->willReturn( true );
$user->method( 'getEmail' )->willReturn( self::VALID_EMAIL );
return $user;
};
$user1 = $getGoodUserCb( 1 );
$user2 = $getGoodUserCb( 2 );
$user3 = $getGoodUserCb( 3 );
$user4 = $getGoodUserCb( 4 );
$badUser = $this->createMock( User::class );
$badUser->method( 'getName' )->willReturn( 'BadUser' );
$badUser->method( 'getId' )->willReturn( 5 );
$badUser->method( 'isRegistered' )->willReturn( true );
$badUser->method( 'getEmail' )->willReturn( '' );
$nonexistUser = $this->createMock( User::class );
$nonexistUser->method( 'getName' )->willReturn( 'Nonexistent user' );
$nonexistUser->method( 'getId' )->willReturn( 0 );
$nonexistUser->method( 'isRegistered' )->willReturn( false );
$nonexistUser->method( 'getEmail' )->willReturn( '' );
return [
'User1' => $user1,
'User2' => $user2,
'User3' => $user3,
'User4' => $user4,
'BadUser' => $badUser,
'Nonexistent user' => $nonexistUser,
];
}
}
PK ! w@9 9 MockServiceWiring.phpnu Iw testPage = Title::makeTitle( NS_MAIN, 'RollbackActionTest' );
$this->vandal = $this->getTestUser()->getUser();
$this->sysop = $this->getTestSysop()->getUser();
$this->editPage( $this->testPage, 'Some text', '', NS_MAIN, $this->sysop );
$this->editPage( $this->testPage, 'Vandalism', '', NS_MAIN, $this->vandal );
}
private function getRollbackAction( WebRequest $request ) {
$context = new DerivativeContext( RequestContext::getMain() );
$context->setTitle( $this->testPage );
$context->setRequest( $request );
$context->setUser( $this->sysop );
$mwServices = $this->getServiceContainer();
return new RollbackAction(
Article::newFromTitle( $this->testPage, $context ),
$context,
$mwServices->getContentHandlerFactory(),
$mwServices->getRollbackPageFactory(),
$mwServices->getUserOptionsLookup(),
$mwServices->getWatchlistManager(),
$mwServices->getCommentFormatter()
);
}
public static function provideRollbackParamFail() {
yield 'No from parameter' => [
'requestParams' => [],
];
yield 'Non existent user' => [
'requestParams' => [
'from' => 'abirvalg',
],
];
yield 'User mismatch' => [
'requestParams' => [
'from' => 'UTSysop',
],
];
}
/**
* @dataProvider provideRollbackParamFail
*/
public function testRollbackParamFail( array $requestParams ) {
$request = new FauxRequest( $requestParams );
$rollbackAction = $this->getRollbackAction( $request );
$this->expectException( ErrorPageError::class );
$rollbackAction->handleRollbackRequest();
}
public function testRollbackTokenMismatch() {
$request = new FauxRequest( [
'from' => $this->vandal->getName(),
'token' => 'abrvalg',
] );
$rollbackAction = $this->getRollbackAction( $request );
$this->expectException( ErrorPageError::class );
$rollbackAction->handleRollbackRequest();
}
public function testRollback() {
$request = new FauxRequest( [
'from' => $this->vandal->getName(),
'token' => $this->sysop->getEditToken( 'rollback' ),
] );
$rollbackAction = $this->getRollbackAction( $request );
$rollbackAction->handleRollbackRequest();
$revisionStore = $this->getServiceContainer()->getRevisionStore();
// Content of latest revision should match the initial.
$latestRev = $revisionStore->getRevisionByTitle( $this->testPage );
$initialRev = $revisionStore->getFirstRevision( $this->testPage );
$this->assertTrue( $latestRev->hasSameContent( $initialRev ) );
// ...but have different rev IDs.
$this->assertNotSame( $latestRev->getId(), $initialRev->getId() );
$recentChange = $revisionStore->getRecentChange( $latestRev );
$this->assertSame( '0', $recentChange->getAttribute( 'rc_bot' ) );
$this->assertSame( $this->sysop->getName(), $recentChange->getAttribute( 'rc_user_text' ) );
}
public function testRollbackMarkBot() {
$request = new FauxRequest( [
'from' => $this->vandal->getName(),
'token' => $this->sysop->getEditToken( 'rollback' ),
'bot' => true,
] );
$rollbackAction = $this->getRollbackAction( $request );
$rollbackAction->handleRollbackRequest();
$revisionStore = $this->getServiceContainer()->getRevisionStore();
$latestRev = $revisionStore->getRevisionByTitle( $this->testPage );
$recentChange = $revisionStore->getRecentChange( $latestRev );
$this->assertSame( '1', $recentChange->getAttribute( 'rc_bot' ) );
}
}
PK ! L% actions/ActionTest.phpnu Iw getContext();
$this->overrideConfigValue(
MainConfigNames::Actions,
[
'null' => null,
'disabled' => false,
'view' => true,
'edit' => true,
'dummy' => true,
'access' => 'ControlledAccessDummyAction',
'unblock' => 'RequiresUnblockDummyAction',
'string' => 'NamedDummyAction',
'declared' => 'NonExistingClassName',
'callable' => [ $this, 'dummyActionCallback' ],
'object' => new InstantiatedDummyAction(
$this->getArticle(),
$context
),
]
);
}
/**
* @param string $requestedAction
* @param WikiPage|null $wikiPage
* @return Action|bool|null
*/
private function getAction(
string $requestedAction,
?WikiPage $wikiPage = null
) {
$context = $this->getContext( $requestedAction );
return Action::factory(
$requestedAction,
$this->getArticle( $wikiPage, $context ),
$context
);
}
/**
* @param WikiPage|null $wikiPage
* @param IContextSource|null $context
* @return Article
*/
private function getArticle(
?WikiPage $wikiPage = null,
?IContextSource $context = null
): Article {
$context ??= $this->getContext();
if ( $wikiPage !== null ) {
$context->setWikiPage( $wikiPage );
$context->setTitle( $wikiPage->getTitle() );
} else {
$wikiPage = $this->getPage();
}
return Article::newFromWikiPage( $wikiPage, $context );
}
private function getPage(): WikiPage {
$title = Title::makeTitle( 0, 'Title' );
return $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
}
/**
* @param string|null $requestedAction
* @return IContextSource
*/
private function getContext(
?string $requestedAction = null
): IContextSource {
$request = new FauxRequest( [ 'action' => $requestedAction ] );
$context = new DerivativeContext( RequestContext::getMain() );
$context->setRequest( $request );
$context->setWikiPage( $this->getPage() );
return $context;
}
public static function provideActions() {
return [
[ 'dummy', 'DummyAction' ],
[ 'string', 'NamedDummyAction' ],
[ 'callable', 'CalledDummyAction' ],
[ 'object', 'InstantiatedDummyAction' ],
// Capitalization is ignored
[ 'DUMMY', 'DummyAction' ],
[ 'STRING', 'NamedDummyAction' ],
// non-existing values
[ 'null', null ],
[ 'undeclared', null ],
[ '', null ],
// disabled action exists but cannot be created
[ 'disabled', false ],
];
}
public static function provideGetActionName() {
return [
'dummy' => [ 'dummy', 'DummyAction' ],
'string' => [ 'string', 'NamedDummyAction' ],
'callable' => [ 'callable', 'CalledDummyAction' ],
'object' => [ 'object', 'InstantiatedDummyAction' ],
// Capitalization is ignored
'dummy (caps)' => [ 'DUMMY', 'DummyAction' ],
'string (caps)' => [ 'STRING', 'NamedDummyAction' ],
// non-existing values
'null (string)' => [ 'null', 'nosuchaction' ],
'undeclared' => [ 'undeclared', 'nosuchaction' ],
'empty' => [ '', 'nosuchaction' ],
// impossible
'null (value)' => [ null, 'view' ],
'false' => [ false, 'nosuchaction' ],
// Compatibility with old URLs
'editredlink' => [ 'editredlink', 'edit' ],
'historysubmit' => [ 'historysubmit', 'view' ],
'disabled not resolvable' => [ 'disabled', 'nosuchaction' ],
];
}
/**
* @dataProvider provideGetActionName
* @param string $requestedAction
* @param string $expected
*/
public function testGetActionName( $requestedAction, $expected ) {
$actionName = Action::getActionName(
$this->getContext( $requestedAction )
);
$this->assertEquals( $expected, $actionName );
}
public function testGetActionName_whenCanNotUseWikiPage_defaultsToView() {
$request = new FauxRequest( [ 'action' => 'edit' ] );
$context = new DerivativeContext( RequestContext::getMain() );
$context->setRequest( $request );
$actionName = Action::getActionName( $context );
$this->assertEquals( 'view', $actionName );
}
/**
* @covers \Action::factory
*
* @dataProvider provideActions
* @param string $requestedAction
* @param string|false|null $expected
*/
public function testActionFactory( string $requestedAction, $expected ) {
$action = $this->getAction( $requestedAction );
if ( is_string( $expected ) ) {
$this->assertInstanceOf( $expected, $action );
} else {
$this->assertSame( $expected, $action );
}
}
public function dummyActionCallback() {
$article = $this->getArticle();
return new CalledDummyAction(
$article,
$article->getContext()
);
}
public function testCanExecute() {
$user = $this->getTestUser()->getUser();
$this->overrideUserPermissions( $user, 'access' );
$action = $this->getAction( 'access' );
$this->assertNull( $action->canExecute( $user ) );
}
public function testCanExecuteNoRight() {
$user = $this->getTestUser()->getUser();
$this->overrideUserPermissions( $user, [] );
$action = $this->getAction( 'access' );
$this->expectException( PermissionsError::class );
$action->canExecute( $user );
}
public function testCanExecuteRequiresUnblock() {
$page = $this->getExistingTestPage();
$action = $this->getAction( 'unblock', $page );
$user = $this->createMock( User::class );
$user->method( 'getWikiId' )->willReturn( WikiAwareEntity::LOCAL );
$block = new DatabaseBlock( [
'address' => $user,
'by' => $this->getTestSysop()->getUser(),
'expiry' => 'infinity',
'sitewide' => false,
] );
$user->expects( $this->once() )
->method( 'getBlock' )
->willReturn( $block );
$permissionManager = $this->createMock( PermissionManager::class );
$permissionManager->method( 'isBlockedFrom' )->willReturn( true );
$this->setService( 'PermissionManager', $permissionManager );
$this->expectException( UserBlockedError::class );
$action->canExecute( $user );
}
}
class DummyAction extends Action {
public function getName() {
return static::class;
}
public function show() {
}
public function execute() {
}
public function canExecute( User $user ) {
$this->checkCanExecute( $user );
}
}
class NamedDummyAction extends DummyAction {
}
class CalledDummyAction extends DummyAction {
}
class InstantiatedDummyAction extends DummyAction {
}
class ControlledAccessDummyAction extends DummyAction {
public function getRestriction() {
return 'access';
}
}
class RequiresUnblockDummyAction extends DummyAction {
public function requiresUnblock() {
return true;
}
}
PK ! n?h9 9 actions/WatchActionTest.phpnu Iw overrideConfigValues( [
MainConfigNames::LanguageCode => 'en',
] );
$this->setService( 'ReadOnlyMode', $this->getDummyReadOnlyMode( false ) );
$testTitle = Title::makeTitle( NS_MAIN, 'UTTest' );
$this->testWikiPage = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $testTitle );
$testContext = new DerivativeContext( RequestContext::getMain() );
$testContext->setTitle( $testTitle );
$this->context = $testContext;
$this->watchAction = $this->getWatchAction(
Article::newFromWikiPage( $this->testWikiPage, $testContext ),
$testContext
);
}
private function getWatchAction( Article $article, IContextSource $context ) {
$mwServices = $this->getServiceContainer();
return new WatchAction(
$article,
$context,
$mwServices->getWatchlistManager(),
$mwServices->getWatchedItemStore()
);
}
/**
* @covers \WatchAction::getName()
*/
public function testGetName() {
$this->assertEquals( 'watch', $this->watchAction->getName() );
}
/**
* @covers \WatchAction::requiresUnblock()
*/
public function testRequiresUnlock() {
$this->assertFalse( $this->watchAction->requiresUnblock() );
}
/**
* @covers \WatchAction::doesWrites()
*/
public function testDoesWrites() {
$this->assertTrue( $this->watchAction->doesWrites() );
}
/**
* @covers \WatchAction::onSubmit()
*/
public function testOnSubmit() {
/** @var Status $actual */
$actual = $this->watchAction->onSubmit( [] );
$this->assertStatusGood( $actual );
}
/**
* @covers \WatchAction::onSubmit()
*/
public function testOnSubmitHookAborted() {
// WatchlistExpiry feature flag.
$this->overrideConfigValue( MainConfigNames::WatchlistExpiry, true );
$testContext = $this->getMockBuilder( DerivativeContext::class )
->onlyMethods( [ 'getRequest' ] )
->setConstructorArgs( [ $this->watchAction->getContext() ] )
->getMock();
// Change the context to have a registered user with correct permission.
$user = new UserIdentityValue( 100, 'User Name' );
$performer = $this->mockUserAuthorityWithPermissions( $user, [ 'editmywatchlist' ] );
$testContext->setAuthority( $performer );
$userFactory = $this->createMock( UserFactory::class );
$userFactory->method( 'newFromUserIdentity' )->willReturn( $this->createMock( User::class ) );
$this->setService( 'UserFactory', $userFactory );
/** @var MockObject|WebRequest $testRequest */
$testRequest = $this->createMock( WebRequest::class );
$testRequest->expects( $this->once() )
->method( 'getVal' )
->willReturn( '6 months' );
$testContext->method( 'getRequest' )->willReturn( $testRequest );
$this->setService( 'WatchedItemStore', $this->getDummyWatchedItemStore() );
$this->watchAction = $this->getWatchAction(
Article::newFromWikiPage( $this->testWikiPage, $testContext ),
$testContext
);
$this->setTemporaryHook( 'WatchArticle', static function () {
return false;
} );
/** @var Status $actual */
$actual = $this->watchAction->onSubmit( [] );
$this->assertInstanceOf( Status::class, $actual );
$this->assertStatusError( 'hookaborted', $actual );
}
/**
* @covers \WatchAction::checkCanExecute()
*/
public function testShowUserNotLoggedIn() {
$notLoggedInUser = new User();
$testContext = new DerivativeContext( $this->watchAction->getContext() );
$testContext->setUser( $notLoggedInUser );
$watchAction = $this->getWatchAction(
Article::newFromWikiPage( $this->testWikiPage, $testContext ),
$testContext
);
$this->expectException( UserNotLoggedIn::class );
$watchAction->show();
}
/**
* @covers \WatchAction::checkCanExecute()
*/
public function testShowUserLoggedInNoException() {
$this->setService( 'PermissionManager', $this->createMock( PermissionManager::class ) );
$registeredUser = $this->createMock( User::class );
$registeredUser->method( 'isRegistered' )->willReturn( true );
$registeredUser->method( 'isNamed' )->willReturn( true );
$testContext = new DerivativeContext( $this->watchAction->getContext() );
$testContext->setUser( $registeredUser );
$watchAction = $this->getWatchAction(
Article::newFromWikiPage( $this->testWikiPage, $testContext ),
$testContext
);
$exception = null;
try {
$watchAction->show();
} catch ( UserNotLoggedIn $e ) {
$exception = $e;
}
$this->assertNull( $exception,
'UserNotLoggedIn exception should not be thrown if user is a registered one.' );
}
/**
* @covers \WatchAction::onSuccess()
*/
public function testOnSuccessMainNamespaceTitle() {
/** @var MockObject|IContextSource $testContext */
$testContext = $this->getMockBuilder( DerivativeContext::class )
->onlyMethods( [ 'msg' ] )
->setConstructorArgs( [ $this->watchAction->getContext() ] )
->getMock();
$testOutput = new OutputPage( $testContext );
$testContext->setOutput( $testOutput );
$testContext->method( 'msg' )->willReturnCallback( static function ( $msgKey ) {
return new RawMessage( $msgKey );
} );
$watchAction = $this->getWatchAction(
Article::newFromWikiPage( $this->testWikiPage, $testContext ),
$testContext
);
$watchAction->onSuccess();
$this->assertEquals( 'addedwatchtext
', $testOutput->getHTML() );
}
/**
* @covers \WatchAction::onSuccess()
*/
public function testOnSuccessTalkPage() {
/** @var MockObject|IContextSource $testContext */
$testContext = $this->getMockBuilder( DerivativeContext::class )
->onlyMethods( [ 'getOutput', 'msg' ] )
->setConstructorArgs( [ $this->watchAction->getContext() ] )
->getMock();
$testOutput = new OutputPage( $testContext );
$testContext->method( 'getOutput' )->willReturn( $testOutput );
$testContext->method( 'msg' )->willReturnCallback( static function ( $msgKey ) {
return new RawMessage( $msgKey );
} );
$talkPageTitle = Title::makeTitle( NS_TALK, 'UTTest' );
$testContext->setTitle( $talkPageTitle );
$watchAction = $this->getWatchAction(
Article::newFromTitle( $talkPageTitle, $testContext ),
$testContext
);
$watchAction->onSuccess();
$this->assertEquals( 'addedwatchtext-talk
', $testOutput->getHTML() );
}
/**
* @dataProvider provideOnSuccessDifferentMessages
*/
public function testOnSuccessDifferentMessages(
$watchlistExpiry, $msg, $prefixedTitle, $submittedExpiry, $expiryLabel
) {
// Fake current time to be 2020-09-17 12:00:00 UTC.
ConvertibleTimestamp::setFakeTime( '20200917120000' );
// WatchlistExpiry feature flag.
$this->overrideConfigValue( MainConfigNames::WatchlistExpiry, $watchlistExpiry );
// Set up context, request, and output.
/** @var MockObject|IContextSource $testContext */
$testContext = $this->getMockBuilder( DerivativeContext::class )
->onlyMethods( [ 'getOutput', 'getRequest', 'getLanguage' ] )
->setConstructorArgs( [ $this->watchAction->getContext() ] )
->getMock();
/** @var MockObject|OutputPage $testOutput */
$testOutput = $this->createMock( OutputPage::class );
$testOutput->expects( $this->once() )
->method( 'addWikiMsg' )
->with( $msg, $prefixedTitle, $expiryLabel );
$testContext->method( 'getOutput' )->willReturn( $testOutput );
// Set language to anything non-English/default, to catch assumptions.
$langDe = $this->getServiceContainer()->getLanguageFactory()->getLanguage( 'de' );
$testContext->method( 'getLanguage' )->willReturn( $langDe );
/** @var MockObject|WebRequest $testRequest */
$testRequest = $this->createMock( WebRequest::class );
$testRequest->expects( $this->once() )
->method( 'getText' )
->willReturn( $submittedExpiry );
$testContext->method( 'getRequest' )->willReturn( $testRequest );
// Call the onSuccess method, and the above mocks will confirm it's correct.
/** @var WatchAction $watchAction */
$watchAction = TestingAccessWrapper::newFromObject(
$this->getWatchAction(
Article::newFromTitle( Title::newFromText( $prefixedTitle ), $testContext ),
$testContext
)
);
$watchAction->onSuccess();
}
public static function provideOnSuccessDifferentMessages() {
return [
[
'wgWatchlistExpiry' => false,
'msg' => 'addedwatchtext',
'prefixedTitle' => 'Foo',
'submittedExpiry' => null,
'expiryLabel' => null,
],
[
'wgWatchlistExpiry' => false,
'msg' => 'addedwatchtext-talk',
'prefixedTitle' => 'Talk:Foo',
'submittedExpiry' => null,
'expiryLabel' => null,
],
[
'wgWatchlistExpiry' => true,
'msg' => 'addedwatchindefinitelytext',
'prefixedTitle' => 'Foo',
'submittedExpiry' => 'infinite',
'expiryLabel' => 'Dauerhaft',
],
[
'wgWatchlistExpiry' => true,
'msg' => 'addedwatchindefinitelytext-talk',
'prefixedTitle' => 'Talk:Foo',
'submittedExpiry' => 'infinite',
'expiryLabel' => 'Dauerhaft',
],
[
'wgWatchlistExpiry' => true,
'msg' => 'addedwatchexpirytext',
'prefixedTitle' => 'Foo',
'submittedExpiry' => '1 week',
'expiryLabel' => '1 Woche',
],
[
'wgWatchlistExpiry' => true,
'msg' => 'addedwatchexpirytext-talk',
'prefixedTitle' => 'Talk:Foo',
'submittedExpiry' => '1 week',
'expiryLabel' => '1 Woche',
],
[
'wgWatchlistExpiry' => true,
'msg' => 'addedwatchexpiryhours',
'prefixedTitle' => 'Foo',
'submittedExpiry' => '2020-09-17T14:00:00Z',
'expiryLabel' => null,
],
[
'wgWatchlistExpiry' => true,
'msg' => 'addedwatchexpiryhours-talk',
'prefixedTitle' => 'Talk:Foo',
'submittedExpiry' => '2020-09-17T14:00:00Z',
'expiryLabel' => null,
],
];
}
/**
* @covers \WatchAction::getExpiryOptions()
*/
public function testGetExpiryOptions() {
// Fake current time to be 2020-06-10T00:00:00Z
ConvertibleTimestamp::setFakeTime( '20200610000000' );
$userIdentity = new UserIdentityValue( 100, 'User Name' );
$target = new TitleValue( 0, 'SomeDbKey' );
$optionsNoExpiry = WatchAction::getExpiryOptions( $this->context, false );
$expectedNoExpiry = [
'options' => [
'Permanent' => 'infinite',
'1 week' => '1 week',
'1 month' => '1 month',
'3 months' => '3 months',
'6 months' => '6 months',
'1 year' => '1 year',
],
'default' => 'infinite'
];
$this->assertSame( $expectedNoExpiry, $optionsNoExpiry );
// Adding a watched item with an expiry a month from the frozen time
$watchedItemMonth = new WatchedItem( $userIdentity, $target, null, '20200710000000' );
$optionsExpiryOneMonth = WatchAction::getExpiryOptions( $this->context, $watchedItemMonth );
$expectedExpiryOneMonth = [
'options' => [
'30 days left' => '2020-07-10T00:00:00Z',
'Permanent' => 'infinite',
'1 week' => '1 week',
'1 month' => '1 month',
'3 months' => '3 months',
'6 months' => '6 months',
'1 year' => '1 year',
],
'default' => '2020-07-10T00:00:00Z'
];
$this->assertSame( $expectedExpiryOneMonth, $optionsExpiryOneMonth );
// Adding a watched item with an expiry 7 days from the frozen time
$watchedItemWeek = new WatchedItem( $userIdentity, $target, null, '20200617000000' );
$optionsExpiryOneWeek = WatchAction::getExpiryOptions( $this->context, $watchedItemWeek );
$expectedOneWeek = [
'options' => [
'7 days left' => '2020-06-17T00:00:00Z',
'Permanent' => 'infinite',
'1 week' => '1 week',
'1 month' => '1 month',
'3 months' => '3 months',
'6 months' => '6 months',
'1 year' => '1 year',
],
'default' => '2020-06-17T00:00:00Z'
];
$this->assertSame( $expectedOneWeek, $optionsExpiryOneWeek );
// Case for when WatchedItem is true
$optionsNoExpiryWIFalse = WatchAction::getExpiryOptions( $this->context, true );
$expectedNoExpiryWIFalse = [
'options' => [
'Permanent' => 'infinite',
'1 week' => '1 week',
'1 month' => '1 month',
'3 months' => '3 months',
'6 months' => '6 months',
'1 year' => '1 year',
],
'default' => 'infinite'
];
$this->assertSame( $expectedNoExpiryWIFalse, $optionsNoExpiryWIFalse );
}
/**
* @covers \WatchAction::getExpiryOptions()
*/
public function testGetExpiryOptionsWithInvalidTranslations() {
$mockMessageLocalizer = $this->createMock( MockMessageLocalizer::class );
$mockLanguage = $this->createMock( Language::class );
$mockLanguage->method( 'getCode' )->willReturn( 'not-english' );
$mockMessage = $this->getMockMessage( 'invalid:invalid, foo:bar, thing' );
$mockMessage->method( 'getLanguage' )->willReturn( $mockLanguage );
$mockMessageLocalizer->expects( $this->exactly( 2 ) )
->method( 'msg' )
->willReturnOnConsecutiveCalls(
$mockMessage,
new Message( 'watchlist-expiry-options' )
);
$expected = WatchAction::getExpiryOptions( new MockMessageLocalizer( 'en' ), false );
$expiryOptions = WatchAction::getExpiryOptions( $mockMessageLocalizer, false );
$this->assertSame( $expected, $expiryOptions );
}
/**
* @covers \WatchAction::getExpiryOptions()
*/
public function testGetExpiryOptionsWithPartialInvalidTranslations() {
$mockMessageLocalizer = $this->createMock( MockMessageLocalizer::class );
$mockMessageLocalizer->expects( $this->once() )
->method( 'msg' )
->with( 'watchlist-expiry-options' )
->willReturn( $this->getMockMessage( 'invalid:invalid, thing, 1 week: 1 week,3 days:3 days' ) );
$expected = [
'options' => [
'1 week' => '1 week',
'3 days' => '3 days',
],
'default' => '1 week'
];
$expiryOptions = WatchAction::getExpiryOptions( $mockMessageLocalizer, false );
$this->assertSame( $expected, $expiryOptions );
}
}
PK ! #Y3 Y3 actions/ActionEntryPointTest.phpnu Iw overrideConfigValues( [
MainConfigNames::Server => 'http://example.org',
MainConfigNames::ScriptPath => '/w',
MainConfigNames::Script => '/w/index.php',
MainConfigNames::LanguageCode => 'en',
] );
// Needed to test redirects to My* special pages as an anonymous user.
$this->disableAutoCreateTempUser();
}
protected function tearDown(): void {
// Restore a scope stack that will run updates immediately
DeferredUpdates::setScopeStack( new DeferredUpdatesScopeMediaWikiStack() );
parent::tearDown();
}
/**
* @param MockEnvironment|WebRequest|array|null $environment
* @param RequestContext|null $context
*
* @return ActionEntryPoint
*/
private function getEntryPoint( $environment = null, ?RequestContext $context = null ) {
if ( !$environment ) {
$environment = new MockEnvironment();
}
if ( is_array( $environment ) ) {
$environment = new FauxRequest( $environment );
}
if ( $environment instanceof WebRequest ) {
$environment = new MockEnvironment( $environment );
}
$entryPoint = new ActionEntryPoint(
$context ?? $environment->makeFauxContext(),
$environment,
$this->getServiceContainer()
);
$entryPoint->enableOutputCapture();
return $entryPoint;
}
public static function provideTryNormaliseRedirect() {
return [
[
// View: Canonical
'url' => 'http://example.org/wiki/Foo_Bar',
'query' => [],
'title' => 'Foo_Bar',
'redirect' => false,
],
[
// View: Escaped title
'url' => 'http://example.org/wiki/Foo%20Bar',
'query' => [],
'title' => 'Foo_Bar',
'redirect' => 'http://example.org/wiki/Foo_Bar',
],
[
// View: Script path
'url' => 'http://example.org/w/index.php?title=Foo_Bar',
'query' => [ 'title' => 'Foo_Bar' ],
'title' => 'Foo_Bar',
'redirect' => false,
],
[
// View: Script path with implicit title from page id
'url' => 'http://example.org/w/index.php?curid=123',
'query' => [ 'curid' => '123' ],
'title' => 'Foo_Bar',
'redirect' => false,
],
[
// View: Script path with implicit title from revision id
'url' => 'http://example.org/w/index.php?oldid=123',
'query' => [ 'oldid' => '123' ],
'title' => 'Foo_Bar',
'redirect' => false,
],
[
// View: Script path without title
'url' => 'http://example.org/w/index.php',
'query' => [],
'title' => 'Main_Page',
'redirect' => 'http://example.org/wiki/Main_Page',
],
[
// View: Script path with empty title
'url' => 'http://example.org/w/index.php?title=',
'query' => [ 'title' => '' ],
'title' => 'Main_Page',
'redirect' => 'http://example.org/wiki/Main_Page',
],
[
// View: Index with escaped title
'url' => 'http://example.org/w/index.php?title=Foo%20Bar',
'query' => [ 'title' => 'Foo Bar' ],
'title' => 'Foo_Bar',
'redirect' => 'http://example.org/wiki/Foo_Bar',
],
[
// View: Script path with escaped title
'url' => 'http://example.org/w/?title=Foo_Bar',
'query' => [ 'title' => 'Foo_Bar' ],
'title' => 'Foo_Bar',
'redirect' => false,
],
[
// View: Root path with escaped title
'url' => 'http://example.org/?title=Foo_Bar',
'query' => [ 'title' => 'Foo_Bar' ],
'title' => 'Foo_Bar',
'redirect' => false,
],
[
// View: Canonical with redundant query
'url' => 'http://example.org/wiki/Foo_Bar?action=view',
'query' => [ 'action' => 'view' ],
'title' => 'Foo_Bar',
'redirect' => false,
],
[
// Edit: Canonical view url with action query
'url' => 'http://example.org/wiki/Foo_Bar?action=edit',
'query' => [ 'action' => 'edit' ],
'title' => 'Foo_Bar',
'redirect' => false,
],
[
// View: Index with action query
'url' => 'http://example.org/w/index.php?title=Foo_Bar&action=view',
'query' => [ 'title' => 'Foo_Bar', 'action' => 'view' ],
'title' => 'Foo_Bar',
'redirect' => false,
],
[
// Edit: Index with action query
'url' => 'http://example.org/w/index.php?title=Foo_Bar&action=edit',
'query' => [ 'title' => 'Foo_Bar', 'action' => 'edit' ],
'title' => 'Foo_Bar',
'redirect' => false,
],
[
// Path with double slash prefix (T100782)
'url' => 'http://example.org//wiki/Double_slash',
'query' => [],
'title' => 'Double_slash',
'redirect' => false,
],
[
// View: Media namespace redirect (T203942)
'url' => 'http://example.org/w/index.php?title=Media:Foo_Bar',
'query' => [ 'title' => 'Foo_Bar' ],
'title' => 'File:Foo_Bar',
'redirect' => 'http://example.org/wiki/File:Foo_Bar',
],
];
}
/**
* @dataProvider provideTryNormaliseRedirect
*/
public function testTryNormaliseRedirect( $url, $query, $title, $expectedRedirect = false ) {
$environment = new MockEnvironment();
$environment->setRequestInfo( $url, $query );
$titleObj = Title::newFromText( $title );
// Set global context since some involved code paths don't yet have context
$context = $environment->makeFauxContext();
$context->setTitle( $titleObj );
$mw = $this->getEntryPoint( $environment, $context );
$method = new ReflectionMethod( $mw, 'tryNormaliseRedirect' );
$method->setAccessible( true );
$ret = $method->invoke( $mw, $titleObj );
$this->assertEquals(
$expectedRedirect !== false,
$ret,
'Return true only when redirecting'
);
$this->assertEquals(
$expectedRedirect ?: '',
$context->getOutput()->getRedirect()
);
}
public function testMainPageIsDomainRoot() {
$this->overrideConfigValue( MainConfigNames::MainPageIsDomainRoot, true );
$environment = new MockEnvironment();
$environment->setRequestInfo( '/' );
// Set global context since some involved code paths don't yet have context
$context = $environment->makeFauxContext();
$entryPoint = $this->getEntryPoint( $environment, $context );
$entryPoint->run();
$expected = '(pagetitle: Main Page)';
Assert::assertStringContainsString( $expected, $entryPoint->getCapturedOutput() );
}
public static function provideParseTitle() {
return [
"No title means main page" => [
'query' => [],
'expected' => 'Main Page',
],
"Empty title also means main page" => [
'query' => wfCgiToArray( '?title=' ),
'expected' => 'Main Page',
],
"Valid title" => [
'query' => wfCgiToArray( '?title=Foo' ),
'expected' => 'Foo',
],
"Invalid title" => [
'query' => wfCgiToArray( '?title=[INVALID]' ),
'expected' => false,
],
"Invalid 'oldid'… means main page? (we show an error elsewhere)" => [
'query' => wfCgiToArray( '?oldid=9999999' ),
'expected' => 'Main Page',
],
"Invalid 'diff'… means main page? (we show an error elsewhere)" => [
'query' => wfCgiToArray( '?diff=9999999' ),
'expected' => 'Main Page',
],
"Invalid 'curid'" => [
'query' => wfCgiToArray( '?curid=9999999' ),
'expected' => false,
],
"'search' parameter with no title provided forces Special:Search" => [
'query' => wfCgiToArray( '?search=foo' ),
'expected' => 'Special:Search',
],
"'action=revisiondelete' forces Special:RevisionDelete even with title" => [
'query' => wfCgiToArray( '?action=revisiondelete&title=Unused' ),
'expected' => 'Special:RevisionDelete',
],
"'action=historysubmit&revisiondelete=1' forces Special:RevisionDelete even with title" => [
'query' => wfCgiToArray( '?action=historysubmit&revisiondelete=1&title=Unused' ),
'expected' => 'Special:RevisionDelete',
],
"'action=editchangetags' forces Special:EditTags even with title" => [
'query' => wfCgiToArray( '?action=editchangetags&title=Unused' ),
'expected' => 'Special:EditTags',
],
"'action=historysubmit&editchangetags=1' forces Special:EditTags even with title" => [
'query' => wfCgiToArray( '?action=historysubmit&editchangetags=1&title=Unused' ),
'expected' => 'Special:EditTags',
],
"No title with 'action' still means main page" => [
'query' => wfCgiToArray( '?action=history' ),
'expected' => 'Main Page',
],
"No title with 'action=delete' does not mean main page, because we want to discourage deleting it by accident :D" => [
'query' => wfCgiToArray( '?action=delete' ),
'expected' => false,
],
];
}
private function doTestParseTitle( array $query, $expected ): void {
if ( $expected === false ) {
$this->expectException( MalformedTitleException::class );
}
$req = new FauxRequest( $query );
$mw = $this->getEntryPoint( $req );
$method = new ReflectionMethod( $mw, 'parseTitle' );
$method->setAccessible( true );
$ret = $method->invoke( $mw, $req );
$this->assertEquals(
$expected,
$ret->getPrefixedText()
);
}
/**
* @dataProvider provideParseTitle
*/
public function testParseTitle( $query, $expected ) {
$this->doTestParseTitle( $query, $expected );
}
public static function provideParseTitleExistingPage(): array {
return [
"Valid 'oldid'" => [
static fn ( WikiPage $page ): array => wfCgiToArray( '?oldid=' . $page->getRevisionRecord()->getId() ),
],
"Valid 'diff'" => [
static fn ( WikiPage $page ): array => wfCgiToArray( '?diff=' . $page->getRevisionRecord()->getId() ),
],
"Valid 'curid'" => [
static fn ( WikiPage $page ): array => wfCgiToArray( '?curid=' . $page->getId() ),
],
];
}
/**
* @dataProvider provideParseTitleExistingPage
*/
public function testParseTitle__existingPage( callable $queryBuildCallback ) {
$pageTitle = 'TestParseTitle test page';
$page = $this->getExistingTestPage( $pageTitle );
$query = $queryBuildCallback( $page );
$this->doTestParseTitle( $query, $pageTitle );
}
/**
* Test a post-send update cannot set cookies (T191537).
* @coversNothing
*/
public function testPostSendJobDoesNotSetCookie() {
// Prevent updates from running immediately by setting
// a plain DeferredUpdatesScopeStack which doesn't allow
// opportunistic updates.
DeferredUpdates::setScopeStack( new DeferredUpdatesScopeStack() );
$mw = TestingAccessWrapper::newFromObject( $this->getEntryPoint() );
/** @var FauxResponse $response */
$response = $mw->getResponse();
// A update that attempts to set a cookie
$jobHasRun = false;
DeferredUpdates::addCallableUpdate( static function () use ( $response, &$jobHasRun ) {
$jobHasRun = true;
$response->setCookie( 'JobCookie', 'yes' );
$response->header( 'Foo: baz' );
} );
$mw->doPostOutputShutdown();
// restInPeace() might have been registered to a callback of
// register_postsend_function() and thus cannot be triggered from
// PHPUnit.
if ( $jobHasRun === false ) {
$mw->restInPeace();
}
$this->assertTrue( $jobHasRun, 'post-send job has run' );
$this->assertNull( $response->getCookie( 'JobCookie' ) );
$this->assertNull( $response->getHeader( 'Foo' ) );
}
public function testInvalidRedirectingOnSpecialPageWithPersonallyIdentifiableTarget() {
$this->overrideConfigValue( MainConfigNames::HideIdentifiableRedirects, true );
$specialTitle = SpecialPage::getTitleFor( 'Mypage', 'in<valid' );
$req = new FauxRequest( [
'title' => $specialTitle->getPrefixedDbKey(),
] );
$req->setRequestURL( $specialTitle->getLinkURL() );
$env = new MockEnvironment( $req );
$context = $env->makeFauxContext();
$context->setTitle( $specialTitle );
$mw = TestingAccessWrapper::newFromObject( $this->getEntryPoint( $env, $context ) );
$this->expectException( BadTitleError::class );
$this->expectExceptionMessage( 'The requested page title contains invalid characters: "<".' );
$mw->performRequest();
}
public function testView() {
$page = $this->getExistingTestPage();
$request = new FauxRequest( [ 'title' => $page->getTitle()->getPrefixedDBkey() ] );
$env = new MockEnvironment( $request );
$entryPoint = $this->getEntryPoint( $env );
$entryPoint->run();
$expected = '<title>(pagetitle: ' . $page->getTitle()->getPrefixedText();
Assert::assertStringContainsString( $expected, $entryPoint->getCapturedOutput() );
}
}
PK ! A" ( actions/ActionFactoryIntegrationTest.phpnu Iw <?php
use MediaWiki\Actions\ActionFactory;
use MediaWiki\Context\RequestContext;
use MediaWiki\MediaWikiServices;
use MediaWiki\Title\Title;
/**
* Test that runs against all core actions to make sure that
* creating an instance of the action works
*
* @coversNothing
* @group Database
*/
class ActionFactoryIntegrationTest extends MediaWikiIntegrationTestCase {
public function testActionFactoryServiceWiring() {
$services = MediaWikiServices::getInstance();
$actionFactory = $services->getActionFactory();
$context = RequestContext::getMain();
$article = Article::newFromTitle( Title::makeTitle( NS_MAIN, 'ActionFactoryServiceWiringTest' ), $context );
$actionSpecs = ( new ReflectionClassConstant( ActionFactory::class, 'CORE_ACTIONS' ) )->getValue();
foreach ( $actionSpecs as $action => $_ ) {
$this->assertInstanceOf( Action::class, $actionFactory->getAction( $action, $article, $context ) );
}
}
}
PK ! 7q
q
SampleTest.phpnu Iw <?php
use MediaWiki\MainConfigNames;
use MediaWiki\Title\Title;
/**
* @coversNothing Just a sample
*/
class SampleTest extends MediaWikiLangTestCase {
/**
* Anything that needs to happen before your tests should go here.
*/
protected function setUp(): void {
// Be sure to call the parent setup and teardown functions.
// This makes sure that all the various cleanup and restorations
// happen as they should (including the restoration for setMwGlobals).
parent::setUp();
// This sets the config settings, and will restore them automatically
// after each test.
$this->overrideConfigValues( [
MainConfigNames::LanguageCode => 'en',
MainConfigNames::CapitalLinks => true,
] );
}
/**
* Anything cleanup you need to do should go here.
*/
protected function tearDown(): void {
parent::tearDown();
}
/**
* Name tests so that PHPUnit can turn them into sentences when
* they run. You are encouraged to use the naming described at:
* https://phpunit.de/manual/6.5/en/other-uses-for-tests.html
*/
public function testTitleObjectStringConversion() {
$title = Title::makeTitle( NS_MAIN, "Text" );
$this->assertInstanceOf( Title::class, $title, "Title creation" );
$this->assertEquals( "Text", $title, "Automatic string conversion" );
$title = Title::makeTitle( NS_MEDIA, "Text" );
$this->assertEquals( "Media:Text", $title, "Title creation with namespace" );
}
/**
* If you want to run the same test with a variety of data, use a data provider.
* See https://phpunit.de/manual/6.5/en/writing-tests-for-phpunit.html
*/
public static function provideTitles() {
return [
[ 'Text', NS_MEDIA, 'Media:Text' ],
[ 'Text', null, 'Text' ],
[ 'text', null, 'Text' ],
[ 'Text', NS_USER, 'User:Text' ],
[ 'Photo.jpg', NS_FILE, 'File:Photo.jpg' ]
];
}
/**
* @dataProvider provideTitles
* See https://phpunit.de/manual/6.5/en/appendixes.annotations.html#appendixes.annotations.dataProvider
*/
public function testCreateBasicListOfTitles( $titleName, $ns, $text ) {
$title = Title::newFromText( $titleName, $ns );
$this->assertEquals( $text, "$title", "see if '$titleName' matches '$text'" );
}
/**
* Instead of putting a bunch of tests in a single test method,
* you should put only one or two tests in each test method. This
* way, the test method names can remain descriptive.
*/
/**
* See https://phpunit.de/manual/6.5/en/writing-tests-for-phpunit.html#writing-tests-for-phpunit.exceptions
*/
public function testTitleObjectFromObject() {
$this->expectException( InvalidArgumentException::class );
Title::newFromText( Title::makeTitle( NS_MAIN, 'Test' ) );
}
}
PK ! R?M M Output/OutputPageTest.phpnu Iw <?php
use MediaWiki\Config\HashConfig;
use MediaWiki\Config\MultiConfig;
use MediaWiki\Context\RequestContext;
use MediaWiki\Html\Html;
use MediaWiki\Language\ILanguageConverter;
use MediaWiki\Language\Language;
use MediaWiki\Language\LanguageCode;
use MediaWiki\Language\RawMessage;
use MediaWiki\Languages\LanguageConverterFactory;
use MediaWiki\MainConfigNames;
use MediaWiki\Output\OutputPage;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Page\PageReference;
use MediaWiki\Page\PageReferenceValue;
use MediaWiki\Page\PageStoreRecord;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Parser\ParserOutputFlags;
use MediaWiki\Permissions\Authority;
use MediaWiki\Permissions\PermissionStatus;
use MediaWiki\Request\ContentSecurityPolicy;
use MediaWiki\Request\FauxRequest;
use MediaWiki\Request\WebRequest;
use MediaWiki\ResourceLoader as RL;
use MediaWiki\ResourceLoader\ResourceLoader;
use MediaWiki\Tests\ResourceLoader\ResourceLoaderTestCase;
use MediaWiki\Tests\ResourceLoader\ResourceLoaderTestModule;
use MediaWiki\Tests\Unit\Permissions\MockAuthorityTrait;
use MediaWiki\Title\Title;
use MediaWiki\Title\TitleValue;
use MediaWiki\User\User;
use MediaWiki\Utils\MWTimestamp;
use PHPUnit\Framework\MockObject\MockObject;
use Wikimedia\DependencyStore\KeyValueDependencyStore;
use Wikimedia\LightweightObjectStore\ExpirationAwareness;
use Wikimedia\Rdbms\FakeResultWrapper;
use Wikimedia\TestingAccessWrapper;
/**
* @author Matthew Flaschen
*
* @group Database
* @group Output
* @covers \MediaWiki\Output\OutputPage
*/
class OutputPageTest extends MediaWikiIntegrationTestCase {
use MockAuthorityTrait;
use MockTitleTrait;
private const SCREEN_MEDIA_QUERY = 'screen and (min-width: 982px)';
private const SCREEN_ONLY_MEDIA_QUERY = 'only screen and (min-width: 982px)';
private const RSS_RC_LINK = '<link rel="alternate" type="application/rss+xml" title=" RSS feed" href="/w/index.php?title=Special:RecentChanges&feed=rss">';
private const ATOM_RC_LINK = '<link rel="alternate" type="application/atom+xml" title=" Atom feed" href="/w/index.php?title=Special:RecentChanges&feed=atom">';
private const RSS_TEST_LINK = '<link rel="alternate" type="application/rss+xml" title=""Test" RSS feed" href="fake-link">';
private const ATOM_TEST_LINK = '<link rel="alternate" type="application/atom+xml" title=""Test" Atom feed" href="fake-link">';
// phpcs:enable
// Ensure that we don't affect the global ResourceLoader state.
protected function setUp(): void {
parent::setUp();
ResourceLoader::clearCache();
$this->overrideConfigValues( [
MainConfigNames::ScriptPath => '/mw',
MainConfigNames::Script => '/mw/index.php',
MainConfigNames::ArticlePath => '/wikipage/$1',
MainConfigNames::Server => 'http://example.org',
MainConfigNames::CanonicalServer => 'https://www.example.org',
] );
$this->overrideConfigValue( MainConfigNames::LanguageCode, 'en' );
}
protected function tearDown(): void {
ResourceLoader::clearCache();
parent::tearDown();
}
/**
* @dataProvider provideRedirect
*/
public function testRedirect( $url, $code = null ) {
$op = $this->newInstance();
if ( isset( $code ) ) {
$op->redirect( $url, $code );
} else {
$op->redirect( $url );
}
$expectedUrl = str_replace( "\n", '', $url );
$this->assertSame( $expectedUrl, $op->getRedirect() );
$this->assertSame( $expectedUrl, $op->mRedirect );
$this->assertSame( $code ?? '302', $op->mRedirectCode );
}
public static function provideRedirect() {
return [
[ 'http://example.com' ],
[ 'http://example.com', '400' ],
[ 'http://example.com', 'squirrels!!!' ],
[ "a\nb" ],
];
}
private function setupFeedLinks( $feed, $types ): OutputPage {
$outputPage = $this->newInstance( [
MainConfigNames::AdvertisedFeedTypes => $types,
MainConfigNames::Feed => $feed,
MainConfigNames::OverrideSiteFeed => false,
MainConfigNames::Script => '/w',
MainConfigNames::Sitename => false,
] );
$outputPage->setTitle( Title::makeTitle( NS_MAIN, 'Test' ) );
$this->overrideConfigValue( MainConfigNames::Script, '/w/index.php' );
return $outputPage;
}
private function assertFeedLinks( OutputPage $outputPage, $message, $present, $non_present ) {
$links = $outputPage->getHeadLinksArray();
foreach ( $present as $link ) {
$this->assertContains( $link, $links, $message );
}
foreach ( $non_present as $link ) {
$this->assertNotContains( $link, $links, $message );
}
}
private function assertFeedUILinks( OutputPage $outputPage, $ui_links ) {
if ( $ui_links ) {
$this->assertTrue( $outputPage->isSyndicated(), 'Syndication should be offered' );
$this->assertGreaterThan( 0, count( $outputPage->getSyndicationLinks() ),
'Some syndication links should be there' );
} else {
$this->assertFalse( $outputPage->isSyndicated(), 'No syndication should be offered' );
$this->assertSame( [], $outputPage->getSyndicationLinks(),
'No syndication links should be there' );
}
}
public static function provideFeedLinkData() {
return [
[
true, [ 'rss' ], 'Only RSS RC link should be offerred',
[ self::RSS_RC_LINK ], [ self::ATOM_RC_LINK ]
],
[
true, [ 'atom' ], 'Only Atom RC link should be offerred',
[ self::ATOM_RC_LINK ], [ self::RSS_RC_LINK ]
],
[
true, [], 'No RC feed formats should be offerred',
[], [ self::ATOM_RC_LINK, self::RSS_RC_LINK ]
],
[
false, [ 'atom' ], 'No RC feeds should be offerred',
[], [ self::ATOM_RC_LINK, self::RSS_RC_LINK ]
],
];
}
public function testSetCanonicalUrl() {
$op = $this->newInstance();
$op->setCanonicalUrl( 'http://example.comm' );
$op->setCanonicalUrl( 'http://example.com' );
$this->assertSame( 'http://example.com', $op->getCanonicalUrl() );
$headLinks = $op->getHeadLinksArray();
$this->assertContains( Html::element( 'link', [
'rel' => 'canonical', 'href' => 'http://example.com'
] ), $headLinks );
$this->assertNotContains( Html::element( 'link', [
'rel' => 'canonical', 'href' => 'http://example.comm'
] ), $headLinks );
}
public static function provideGetHeadLinksArray() {
return [
[
[ MainConfigNames::EnableCanonicalServerLink => true ],
'https://www.example.org/xyzzy/Hello',
true,
'/xyzzy/Hello'
],
[
[ MainConfigNames::EnableCanonicalServerLink => true ],
'https://www.example.org/wikipage/My_test_page',
true,
null
],
[
[ MainConfigNames::EnableCanonicalServerLink => true ],
'https://www.mediawiki.org/wiki/Manual:FauxRequest.php',
false,
null
],
];
}
/**
* @dataProvider provideGetHeadLinksArray
*/
public function testGetHeadLinksArray( $config, $canonicalUrl, $isArticleRelated, $canonicalUrlToSet = null ) {
$request = new FauxRequest();
$request->setRequestURL( 'https://www.mediawiki.org/wiki/Manual:FauxRequest.php' );
$op = $this->newInstance( $config, $request );
if ( $canonicalUrlToSet ) {
$op->setCanonicalUrl( $canonicalUrlToSet );
}
$op->setArticleRelated( $isArticleRelated );
$headLinks = $op->getHeadLinksArray();
$this->assertSame(
Html::element( 'link',
[ 'rel' => 'canonical', 'href' => $canonicalUrl ]
),
$headLinks['link-canonical']
);
}
/**
* Test the generation of hreflang Tags when site language has variants
*/
public function testGetLanguageVariantUrl() {
$this->overrideConfigValue( MainConfigNames::LanguageCode, 'zh' );
$op = $this->newInstance();
$headLinks = $op->getHeadLinksArray();
# T123901, T305540, T108443: Don't use language variant link for mixed-variant variant
# (the language code with converter / the main code)
$this->assertSame(
Html::element( 'link', [ 'rel' => 'alternate', 'hreflang' => 'zh',
'href' => 'http://example.org/wikipage/My_test_page' ] ),
$headLinks['link-alternate-language-zh']
);
# Make sure alternate URLs use BCP 47 codes in hreflang
$this->assertSame(
Html::element( 'link', [ 'rel' => 'alternate', 'hreflang' => 'zh-Hant-TW',
'href' => 'http://example.org/mw/index.php?title=My_test_page&variant=zh-tw' ] ),
$headLinks['link-alternate-language-zh-hant-tw']
);
# Make sure $wgVariantArticlePath work
# We currently use MediaWiki internal language code as the primary variant URL parameter
$this->overrideConfigValues( [
MainConfigNames::LanguageCode => 'zh',
MainConfigNames::VariantArticlePath => '/$2/$1',
] );
$op = $this->newInstance();
$headLinks = $op->getHeadLinksArray();
$this->assertSame(
Html::element( 'link', [ 'rel' => 'alternate', 'hreflang' => 'zh-Hant-TW',
'href' => 'http://example.org/zh-tw/My_test_page' ] ),
$headLinks['link-alternate-language-zh-hant-tw']
);
}
public static function provideCanonicalUrlAndAlternateUrlData() {
# $messsage, $action, $urlVariant, $canonicalUrl, $altUrlLangCode, $present, $nonpresent
return [
[
'Non-specified variant with view action - '
. 'We currently use MediaWiki internal codes as the primary URL parameter',
null,
null,
'https://www.example.org/wikipage/My_test_page',
'zh-tw',
'http://example.org/mw/index.php?title=My_test_page&variant=zh-tw',
'http://example.org/mw/index.php?title=My_test_page&variant=zh-hant-tw',
],
[
'Specified zh-tw variant with view action - '
. 'Canonical URL and alternate URL should be the same; '
. 'Alternate URL should be kept even when it is the current page view language',
null,
'zh-tw',
'https://www.example.org/mw/index.php?title=My_test_page&variant=zh-tw',
'zh-tw',
'http://example.org/mw/index.php?title=My_test_page&variant=zh-tw',
'http://example.org/mw/index.php?title=My_test_page&variant=zh-hant-tw',
],
[
'Non-specified variant with history action - '
. 'There should be no alternate URLs for language variants'
. 'There should be no alternate URLs for language variants',
'history',
null,
'https://www.example.org/mw/index.php?title=My_test_page&action=history',
'zh-tw',
null,
'https://www.example.org/mw/index.php?title=My_test_page&action=history&variant=zh-tw',
],
[
'Specified zh-tw variant with history action - '
. 'There should be no alternate URLs for language variants',
'history',
'zh-tw',
'https://www.example.org/mw/index.php?title=My_test_page&action=history',
'zh-tw',
null,
'https://www.example.org/mw/index.php?title=My_test_page&action=history&variant=zh-tw',
],
];
}
/**
* @dataProvider provideCanonicalUrlAndAlternateUrlData
*/
public function testCanonicalUrlAndAlternateUrls(
$messsage, $action, $urlVariant, $canonicalUrl, $altUrlLangCode, $present, $nonpresent
) {
$req = new FauxRequest( [
'title' => 'My_test_page',
'action' => $action,
'variant' => $urlVariant,
] );
$this->setRequest( $req );
$this->overrideConfigValue( MainConfigNames::LanguageCode, 'zh' );
$op = $this->newInstance( [ MainConfigNames::EnableCanonicalServerLink => true ], $req );
$bcp47 = LanguageCode::bcp47( $altUrlLangCode );
$bcp47Lowercase = strtolower( $bcp47 );
$headLinks = $op->getHeadLinksArray();
$this->assertSame(
Html::element( 'link', [ 'rel' => 'canonical', 'href' => $canonicalUrl ] ),
$headLinks['link-canonical'],
$messsage
);
if ( isset( $present ) ) {
$this->assertSame(
Html::element(
'link',
[
'rel' => 'alternate',
'hreflang' => $bcp47,
'href' => $present,
]
),
$headLinks['link-alternate-language-' . $bcp47Lowercase],
$messsage
);
}
$this->assertNotContains(
Html::element(
'link',
[ 'rel' => 'alternate', 'hreflang' => $bcp47, 'href' => $nonpresent, ]
),
$headLinks,
$messsage
);
}
public function testSetCopyrightUrl() {
$op = $this->newInstance();
$op->setCopyrightUrl( 'http://example.com' );
$this->assertSame(
Html::element( 'link', [ 'rel' => 'license', 'href' => 'http://example.com' ] ),
$op->getHeadLinksArray()['copyright']
);
}
/**
* @dataProvider provideFeedLinkData
*/
public function testRecentChangesFeed( $feed, $advertised_feed_types,
$message, $present, $non_present ) {
$outputPage = $this->setupFeedLinks( $feed, $advertised_feed_types );
$this->assertFeedLinks( $outputPage, $message, $present, $non_present );
}
public static function provideAdditionalFeedData() {
return [
[
true, [ 'atom' ], 'Additional Atom feed should be offered',
'atom',
[ self::ATOM_TEST_LINK, self::ATOM_RC_LINK ],
[ self::RSS_TEST_LINK, self::RSS_RC_LINK ],
true,
],
[
true, [ 'rss' ], 'Additional RSS feed should be offered',
'rss',
[ self::RSS_TEST_LINK, self::RSS_RC_LINK ],
[ self::ATOM_TEST_LINK, self::ATOM_RC_LINK ],
true,
],
[
true, [ 'rss' ], 'Additional Atom feed should NOT be offered with RSS enabled',
'atom',
[ self::RSS_RC_LINK ],
[ self::RSS_TEST_LINK, self::ATOM_TEST_LINK, self::ATOM_RC_LINK ],
false,
],
[
false, [ 'atom' ], 'Additional Atom feed should NOT be offered, all feeds disabled',
'atom',
[],
[
self::RSS_TEST_LINK, self::ATOM_TEST_LINK,
self::ATOM_RC_LINK, self::ATOM_RC_LINK,
],
false,
],
];
}
/**
* @dataProvider provideAdditionalFeedData
*/
public function testAdditionalFeeds( $feed, $advertised_feed_types, $message,
$additional_feed_type, $present, $non_present, $any_ui_links ) {
$outputPage = $this->setupFeedLinks( $feed, $advertised_feed_types );
$outputPage->addFeedLink( $additional_feed_type, 'fake-link' );
$this->assertFeedLinks( $outputPage, $message, $present, $non_present );
$this->assertFeedUILinks( $outputPage, $any_ui_links );
}
// @todo How to test setStatusCode?
public function testMetaTags() {
$op = $this->newInstance();
$op->addMeta( 'http:expires', '0' );
$op->addMeta( 'keywords', 'first' );
$op->addMeta( 'keywords', 'second' );
$op->addMeta( 'og:title', 'Ta-duh' );
$expected = [
[ 'http:expires', '0' ],
[ 'keywords', 'first' ],
[ 'keywords', 'second' ],
[ 'og:title', 'Ta-duh' ],
];
$this->assertSame( $expected, $op->getMetaTags() );
$links = $op->getHeadLinksArray();
$this->assertContains( '<meta http-equiv="expires" content="0">', $links );
$this->assertContains( '<meta name="keywords" content="first">', $links );
$this->assertContains( '<meta name="keywords" content="second">', $links );
$this->assertContains( '<meta property="og:title" content="Ta-duh">', $links );
$this->assertArrayHasKey( 'meta-robots', $links );
}
public function testAddLink() {
$op = $this->newInstance();
$links = [
[],
[ 'rel' => 'foo', 'href' => 'http://example.com' ],
];
foreach ( $links as $link ) {
$op->addLink( $link );
}
$this->assertSame( $links, $op->getLinkTags() );
$result = $op->getHeadLinksArray();
foreach ( $links as $link ) {
$this->assertContains( Html::element( 'link', $link ), $result );
}
}
public function testAddScript() {
$op = $this->newInstance();
$op->addScript( 'some random string' );
$this->assertStringContainsString(
"\nsome random string\n",
"\n" . $op->getBottomScripts() . "\n"
);
}
public function testAddScriptFile() {
$op = $this->newInstance();
$op->addScriptFile( '/somescript.js' );
$op->addScriptFile( '//example.com/somescript.js' );
$this->assertStringContainsString(
"\n" . Html::linkedScript( '/somescript.js' ) .
Html::linkedScript( '//example.com/somescript.js' ) . "\n",
"\n" . $op->getBottomScripts() . "\n"
);
}
public function testAddInlineScript() {
$op = $this->newInstance();
$op->addInlineScript( 'let foo = "bar";' );
$op->addInlineScript( 'alert( foo );' );
$this->assertStringContainsString(
"\n" . Html::inlineScript( "\nlet foo = \"bar\";\n" ) . "\n" .
Html::inlineScript( "\nalert( foo );\n" ) . "\n",
"\n" . $op->getBottomScripts() . "\n"
);
}
// @todo How to test addContentOverride(Callback)?
public function testHeadItems() {
$op = $this->newInstance();
$op->addHeadItem( 'a', 'b' );
$op->addHeadItems( [ 'c' => '<d>&', 'e' => 'f', 'a' => 'q' ] );
$op->addHeadItem( 'e', 'g' );
$op->addHeadItems( 'x' );
$this->assertSame( [ 'a' => 'q', 'c' => '<d>&', 'e' => 'g', 'x' ],
$op->getHeadItemsArray() );
$this->assertTrue( $op->hasHeadItem( 'a' ) );
$this->assertTrue( $op->hasHeadItem( 'c' ) );
$this->assertTrue( $op->hasHeadItem( 'e' ) );
$this->assertTrue( $op->hasHeadItem( '0' ) );
$this->assertStringContainsString( "\nq\n<d>&\ng\nx\n",
'' . $op->headElement( $op->getContext()->getSkin() ) );
}
public function testHeadItemsParserOutput() {
$op = $this->newInstance();
$stubPO1 = $this->createParserOutputStub( 'getHeadItems', [ 'a' => 'b' ] );
$op->addParserOutputMetadata( $stubPO1 );
$stubPO2 = $this->createParserOutputStub( 'getHeadItems',
[ 'c' => '<d>&', 'e' => 'f', 'a' => 'q' ] );
$op->addParserOutputMetadata( $stubPO2 );
$stubPO3 = $this->createParserOutputStub( 'getHeadItems', [ 'e' => 'g' ] );
$op->addParserOutput( $stubPO3 );
$stubPO4 = $this->createParserOutputStub( 'getHeadItems', [ 'x' ] );
$op->addParserOutputMetadata( $stubPO4 );
$this->assertSame( [ 'a' => 'q', 'c' => '<d>&', 'e' => 'g', 'x' ],
$op->getHeadItemsArray() );
$this->assertTrue( $op->hasHeadItem( 'a' ) );
$this->assertTrue( $op->hasHeadItem( 'c' ) );
$this->assertTrue( $op->hasHeadItem( 'e' ) );
$this->assertTrue( $op->hasHeadItem( '0' ) );
$this->assertFalse( $op->hasHeadItem( 'b' ) );
$this->assertStringContainsString( "\nq\n<d>&\ng\nx\n",
'' . $op->headElement( $op->getContext()->getSkin() ) );
}
public function testCSPParserOutput() {
$this->overrideConfigValue( MainConfigNames::CSPHeader, [] );
foreach ( [ 'Default', 'Script', 'Style' ] as $type ) {
$op = $this->newInstance();
$ltype = strtolower( $type );
$stubPO1 = $this->createParserOutputStub( "getExtraCSP{$type}Srcs", [ "{$ltype}src.com" ] );
$op->addParserOutputMetadata( $stubPO1 );
$csp = TestingAccessWrapper::newFromObject( $op->getCSP() );
$actual = $csp->makeCSPDirectives( [ 'default-src' => [] ], false );
$regex = '/(^|;)\s*' . $ltype . '-src\s[^;]*' . $ltype . 'src\.com[\s;]/';
$this->assertMatchesRegularExpression( $regex, $actual, $type );
}
}
public function testAddBodyClasses() {
$op = $this->newInstance();
$op->addBodyClasses( 'a' );
$op->addBodyClasses( 'mediawiki' );
$op->addBodyClasses( 'b c' );
$op->addBodyClasses( [ 'd', 'e' ] );
$op->addBodyClasses( 'a' );
$this->assertStringContainsString( '<body class="a mediawiki b c d e ',
'' . $op->headElement( $op->getContext()->getSkin() ) );
}
public function testArticleBodyOnly() {
$op = $this->newInstance();
$this->assertFalse( $op->getArticleBodyOnly() );
$op->setArticleBodyOnly( true );
$this->assertTrue( $op->getArticleBodyOnly() );
$op->addHTML( '<b>a</b>' );
$this->assertSame( '<b>a</b>', $op->output( true ) );
}
public function testProperties() {
$op = $this->newInstance();
$this->assertNull( $op->getProperty( 'foo' ) );
$op->setProperty( 'foo', 'bar' );
$op->setProperty( 'baz', 'quz' );
$this->assertSame( 'bar', $op->getProperty( 'foo' ) );
$this->assertSame( 'quz', $op->getProperty( 'baz' ) );
}
/**
* @dataProvider provideCheckLastModified
*/
public function testCheckLastModified(
$timestamp, $ifModifiedSince, $expected, $config = [], $callback = null
) {
$request = new FauxRequest();
if ( $ifModifiedSince ) {
if ( is_numeric( $ifModifiedSince ) ) {
// Unix timestamp
$ifModifiedSince = date( 'D, d M Y H:i:s', $ifModifiedSince ) . ' GMT';
}
$request->setHeader( 'If-Modified-Since', $ifModifiedSince );
}
// Make sure it's not too recent
$config['CacheEpoch'] ??= '20000101000000';
$config['CachePages'] ??= true;
$op = $this->newInstance( $config, $request );
if ( $callback ) {
$callback( $op, $this );
}
// Ignore complaint about not being able to disable compression
$this->assertEquals( $expected, @$op->checkLastModified( $timestamp ) );
}
public function provideCheckLastModified() {
$lastModified = time() - 3600;
return [
'Timestamp 0' =>
[ '0', $lastModified, false ],
'Timestamp Unix epoch' =>
[ '19700101000000', $lastModified, false ],
'Timestamp same as If-Modified-Since' =>
[ $lastModified, $lastModified, true ],
'Timestamp one second after If-Modified-Since' =>
[ $lastModified + 1, $lastModified, false ],
'No If-Modified-Since' =>
[ $lastModified + 1, null, false ],
'Malformed If-Modified-Since' =>
[ $lastModified + 1, 'GIBBERING WOMBATS !!!', false ],
'Non-standard IE-style If-Modified-Since' =>
[ $lastModified, date( 'D, d M Y H:i:s', $lastModified ) . ' GMT; length=5202',
true ],
// @todo Should we fix this behavior to match the spec? Probably no reason to.
'If-Modified-Since not per spec but we accept it anyway because strtotime does' =>
[ $lastModified, "@$lastModified", true ],
'$wgCachePages = false' =>
[ $lastModified, $lastModified, false, [ MainConfigNames::CachePages => false ] ],
'$wgCacheEpoch' =>
[ $lastModified, $lastModified, false,
[ MainConfigNames::CacheEpoch => wfTimestamp( TS_MW, $lastModified + 1 ) ] ],
'Recently-touched user' =>
[ $lastModified, $lastModified, false, [],
function ( OutputPage $op ) {
$op->getContext()->setUser( $this->getTestUser()->getUser() );
} ],
'After CDN expiry' =>
[ $lastModified, $lastModified, false,
[ MainConfigNames::UseCdn => true, MainConfigNames::CdnMaxAge => 3599 ] ],
'Hook allows cache use' =>
[ $lastModified + 1, $lastModified, true, [],
static function ( $op, $that ) {
$that->setTemporaryHook( 'OutputPageCheckLastModified',
static function ( &$modifiedTimes ) {
$modifiedTimes = [ 1 ];
}
);
} ],
'Hooks prohibits cache use' =>
[ $lastModified, $lastModified, false, [],
static function ( $op, $that ) {
$that->setTemporaryHook( 'OutputPageCheckLastModified',
static function ( &$modifiedTimes ) {
$modifiedTimes = [ max( $modifiedTimes ) + 1 ];
}
);
} ],
];
}
// @todo How to test setLastModified?
public function testSetRobotPolicy() {
$op = $this->newInstance();
$op->setRobotPolicy( 'noindex, nofollow' );
$links = $op->getHeadLinksArray();
$this->assertContains( '<meta name="robots" content="noindex,nofollow,max-image-preview:standard">', $links );
}
public function testSetRobotsOptions() {
$op = $this->newInstance();
$op->setRobotPolicy( 'nofollow' );
$op->setRobotsOptions( [ 'max-snippet' => '500' ] );
$op->setIndexPolicy( 'index' );
$links = $op->getHeadLinksArray();
$this->assertContains( '<meta name="robots" content="index,nofollow,max-image-preview:standard,max-snippet:500">', $links );
$op->setFollowPolicy( 'follow' );
$links = $op->getHeadLinksArray();
$this->assertContains(
'<meta name="robots" content="max-image-preview:standard,max-snippet:500">',
$links,
'When index,follow (browser default) omit'
);
$op->setIndexPolicy( 'noindex' );
$links = $op->getHeadLinksArray();
$this->assertContains(
'<meta name="robots" content="noindex,follow,max-image-preview:standard,max-snippet:500">',
$links,
'noindex takes precedence over index'
);
// Deprecated behavior: for OutputPage (unlike ParserOutput) we can
// reset to 'index' after 'noindex' has been set.
$this->filterDeprecated( '/OutputPage::setIndexPolicy with index after noindex/' );
$op->setIndexPolicy( 'index' );
$links = $op->getHeadLinksArray();
$this->assertContains(
'<meta name="robots" content="max-image-preview:standard,max-snippet:500">',
$links,
'index can reset noindex (deprecated)'
);
}
public function testGetRobotPolicy() {
$op = $this->newInstance();
$op->setRobotPolicy( 'noindex, follow' );
$policy = $op->getRobotPolicy();
$this->assertSame( 'noindex,follow', $policy );
}
/**
* This test is safe to remove once ::setIndexPolicy() is removed.
* @covers \MediaWiki\Output\OutputPage::setIndexPolicy
*/
public function testSetIndexPoliciesBackCompat() {
$op = $this->newInstance();
$this->assertSame( "", $op->getMetadata()->getIndexPolicy() );
$op->setIndexPolicy( 'index' );
$this->assertEquals( "index", $op->getIndexPolicy() );
$this->assertEquals( "index", $op->getMetadata()->getIndexPolicy() );
$op->setIndexPolicy( 'noindex' );
$this->assertEquals( "noindex", $op->getIndexPolicy() );
$this->assertEquals( "noindex", $op->getMetadata()->getIndexPolicy() );
}
/**
* @covers \MediaWiki\Output\OutputPage::getMetadata
* @covers \MediaWiki\Output\OutputPage::getIndexPolicy
* @covers \MediaWiki\Output\OutputPage::setFollowPolicy
* @covers \MediaWiki\Output\OutputPage::getHeadLinksArray
*/
public function testSetIndexFollowPolicies() {
$op = $this->newInstance();
$this->assertSame( "", $op->getMetadata()->getIndexPolicy() );
$this->assertEquals( "index", $op->getIndexPolicy() );
$op->getMetadata()->setIndexPolicy( 'noindex' );
$this->assertEquals( "noindex", $op->getIndexPolicy() );
$op->setFollowPolicy( 'nofollow' );
$links = $op->getHeadLinksArray();
$this->assertContains( '<meta name="robots" content="noindex,nofollow,max-image-preview:standard">', $links );
}
private function extractHTMLTitle( OutputPage $op ) {
$html = $op->headElement( $op->getContext()->getSkin() );
// OutputPage should always output the title in a nice format such that regexes will work
// fine. If it doesn't, we'll fail the tests.
preg_match_all( '!<title>(.*?) !', $html, $matches );
$this->assertLessThanOrEqual( 1, count( $matches[1] ), 'More than one !' );
return $matches[1][0] ?? null;
}
/**
* Shorthand for getting the text of a message, in content language.
* @param MessageLocalizer $op
* @param mixed ...$msgParams
* @return string
*/
private static function getMsgText( MessageLocalizer $op, ...$msgParams ) {
return $op->msg( ...$msgParams )->inContentLanguage()->text();
}
public function testHTMLTitle() {
$op = $this->newInstance();
// Default
$this->assertSame( '', $op->getHTMLTitle() );
$this->assertSame( '', $op->getPageTitle() );
$this->assertSame(
$this->getMsgText( $op, 'pagetitle', '' ),
$this->extractHTMLTitle( $op )
);
// Set to string
$op->setHTMLTitle( 'Potatoes will eat me' );
$this->assertSame( 'Potatoes will eat me', $op->getHTMLTitle() );
$this->assertSame( 'Potatoes will eat me', $this->extractHTMLTitle( $op ) );
// Shouldn't have changed the page title
$this->assertSame( '', $op->getPageTitle() );
// Set to message
$msg = $op->msg( 'mainpage' );
$op->setHTMLTitle( $msg );
$this->assertSame( $msg->text(), $op->getHTMLTitle() );
$this->assertSame( $msg->text(), $this->extractHTMLTitle( $op ) );
$this->assertSame( '', $op->getPageTitle() );
}
public function testSetRedirectedFrom() {
$op = $this->newInstance();
$op->setRedirectedFrom( new PageReferenceValue( NS_TALK, 'Some page', PageReference::LOCAL ) );
$this->assertSame( 'Talk:Some_page', $op->getJSVars()['wgRedirectedFrom'] );
}
public function testPageTitle() {
// We don't test the actual HTML output anywhere, because that's up to the skin.
$op = $this->newInstance();
// Test default
$this->assertSame( '', $op->getPageTitle() );
$this->assertSame( '', $op->getHTMLTitle() );
// Test set to plain text
$op->setPageTitle( 'foobar' );
$this->assertSame( 'foobar', $op->getPageTitle() );
// HTML title should change as well
$this->assertSame( $this->getMsgText( $op, 'pagetitle', 'foobar' ), $op->getHTMLTitle() );
// Test set to text with good and bad HTML. We don't try to be *too*
// comprehensive here, that belongs in Sanitizer tests, but we'll
// address the issues specifically noted in T298401/T67747 at least...
$sanitizerTests = [
[
'input' => '<script>a</script>&<i>b</i>',
'getPageTitle' => '<script>a</script>&<i>b</i>',
'getHTMLTitle' => '<script>a</script>&b',
],
[
'input' => '<code style="display:none">', # T298401
'getPageTitle' => '<code style="display:none"></code>',
'getHTMLTitle' => '',
],
[
'input' => '<b>Foo bar<b>', # T67747
'getPageTitle' => '<b>Foo bar<b></b></b>',
'getHTMLTitle' => 'Foo bar',
],
];
foreach ( $sanitizerTests as $case ) {
$op->setPageTitle( $case['input'] );
$this->assertSame( $case['getPageTitle'], $op->getPageTitle() );
$this->assertSame(
$this->getMsgText( $op, 'pagetitle', $case['getHTMLTitle'] ),
$op->getHTMLTitle()
);
}
// Test set to message (deprecated unescaped)
$text = $this->getMsgText( $op, 'mainpage' );
$op->setPageTitleMsg( $op->msg( 'mainpage' )->inContentLanguage() );
$this->assertSame( $text, $op->getPageTitle() );
$this->assertSame( $this->getMsgText( $op, 'pagetitle', $text ), $op->getHTMLTitle() );
// Test set to message (::setPageTitleMsg(), escaped)
$msg = ( new RawMessage( 'nope:<span>$1 yes:$2' ) )
->plaintextParams( '</span>' )
->rawParams( '<span>!</span>' );
// preferred ::setPageTitleMsg(Msg)
$op->setPageTitleMsg( $msg );
$this->assertSame( 'nope:<span></span> yes:<span>!</span>', $op->getPageTitle() );
// Note that HTML title is unescaped plaintext, it is expected to be
// HTML escaped before becoming the <title> element.
$this->assertSame( $this->getMsgText( $op, 'pagetitle', 'nope:<span></span> yes:!' ), $op->getHTMLTitle() );
// deprecated ::setPageTitle(Message), doesn't escape either
// the localized message or the plaintext parameters
$this->filterDeprecated( '/OutputPage::setPageTitle with Message argument/' );
$op->setPageTitle( $msg );
$this->assertSame( "nope:<span></span> yes:<span>!</span>", $op->getPageTitle() );
}
public function testSetTitle() {
$op = $this->newInstance();
$this->assertSame( 'My test page', $op->getTitle()->getPrefixedText() );
$op->setTitle( Title::makeTitle( NS_MAIN, 'Another test page' ) );
$this->assertSame( 'Another test page', $op->getTitle()->getPrefixedText() );
}
public function testSubtitle() {
$op = $this->newInstance();
$this->assertSame( '', $op->getSubtitle() );
$op->addSubtitle( '<b>foo</b>' );
$this->assertSame( '<b>foo</b>', $op->getSubtitle() );
$op->addSubtitle( $op->msg( 'mainpage' )->inContentLanguage() );
$this->assertSame(
"<b>foo</b><br />\n\t\t\t\t" . $this->getMsgText( $op, 'mainpage' ),
$op->getSubtitle()
);
$op->setSubtitle( 'There can be only one' );
$this->assertSame( 'There can be only one', $op->getSubtitle() );
$op->clearSubtitle();
$this->assertSame( '', $op->getSubtitle() );
}
/**
* @dataProvider provideBacklinkSubtitle
*/
public function testBuildBacklinkSubtitle( $titles, $queries, $contains, $notContains ) {
if ( count( $titles ) > 1 ) {
// Not applicable
$this->assertTrue( true );
return;
}
$title = $titles[0];
$query = $queries[0];
$str = OutputPage::buildBacklinkSubtitle( $title, $query )->text();
foreach ( $contains as $substr ) {
$this->assertStringContainsString( $substr, $str );
}
foreach ( $notContains as $substr ) {
$this->assertStringNotContainsString( $substr, $str );
}
}
/**
* @dataProvider provideBacklinkSubtitle
*/
public function testAddBacklinkSubtitle( $titles, $queries, $contains, $notContains ) {
$op = $this->newInstance();
foreach ( $titles as $i => $unused ) {
$op->addBacklinkSubtitle( $titles[$i], $queries[$i] );
}
$str = $op->getSubtitle();
foreach ( $contains as $substr ) {
$this->assertStringContainsString( $substr, $str );
}
foreach ( $notContains as $substr ) {
$this->assertStringNotContainsString( $substr, $str );
}
}
public function provideBacklinkSubtitle() {
$page1title = $this->makeMockTitle( 'Page 1', [ 'redirect' => true ] );
$page1ref = new PageReferenceValue( NS_MAIN, 'Page 1', PageReference::LOCAL );
$row = [
'page_id' => 28,
'page_namespace' => NS_MAIN,
'page_title' => 'Page 2',
'page_latest' => 75,
'page_is_redirect' => true,
'page_is_new' => true,
'page_touched' => '20200101221133',
'page_lang' => 'en',
];
$page2rec = new PageStoreRecord( (object)$row, PageReference::LOCAL );
$special = new PageReferenceValue( NS_SPECIAL, 'BlankPage', PageReference::LOCAL );
return [
[
[ $page1title ],
[ [] ],
[ 'Page 1' ],
[ 'redirect', 'Page 2' ],
],
[
[ $page2rec ],
[ [] ],
[ 'redirect=no' ],
[ 'Page 1' ],
],
[
[ $special ],
[ [] ],
[ 'Special:BlankPage' ],
[ 'redirect=no' ],
],
[
[ $page1ref ],
[ [ 'action' => 'edit' ] ],
[ 'action=edit' ],
[],
],
[
[ $page1ref, $page2rec ],
[ [], [] ],
[ 'Page 1', 'Page 2', "<br />\n\t\t\t\t" ],
[],
],
// @todo Anything else to test?
];
}
public function testPrintable() {
$op = $this->newInstance();
$this->assertFalse( $op->isPrintable() );
$op->setPrintable();
$this->assertTrue( $op->isPrintable() );
}
public function testDisable() {
$op = $this->newInstance();
$this->assertFalse( $op->isDisabled() );
$this->assertNotSame( '', $op->output( true ) );
$op->disable();
$this->assertTrue( $op->isDisabled() );
$this->assertSame( '', $op->output( true ) );
}
public function testShowNewSectionLink() {
$op = $this->newInstance();
$this->assertFalse( $op->showNewSectionLink() );
$this->assertFalse( $op->getOutputFlag( ParserOutputFlags::NEW_SECTION ) );
$pOut1 = $this->createParserOutputStubWithFlags(
[ 'getNewSection' => true ], [ ParserOutputFlags::NEW_SECTION ]
);
$op->addParserOutputMetadata( $pOut1 );
$this->assertTrue( $op->showNewSectionLink() );
$this->assertTrue( $op->getOutputFlag( ParserOutputFlags::NEW_SECTION ) );
$pOut2 = $this->createParserOutputStub( 'getNewSection', false );
$op->addParserOutput( $pOut2 );
$this->assertFalse( $op->showNewSectionLink() );
// Note that flags are OR'ed together, and not reset.
$this->assertTrue( $op->getOutputFlag( ParserOutputFlags::NEW_SECTION ) );
}
public function testForceHideNewSectionLink() {
$op = $this->newInstance();
$this->assertFalse( $op->forceHideNewSectionLink() );
$this->assertFalse( $op->getOutputFlag( ParserOutputFlags::HIDE_NEW_SECTION ) );
$pOut1 = $this->createParserOutputStubWithFlags(
[ 'getHideNewSection' => true ], [ ParserOutputFlags::HIDE_NEW_SECTION ]
);
$op->addParserOutputMetadata( $pOut1 );
$this->assertTrue( $op->forceHideNewSectionLink() );
$this->assertTrue( $op->getOutputFlag( ParserOutputFlags::HIDE_NEW_SECTION ) );
$pOut2 = $this->createParserOutputStub( 'getHideNewSection', false );
$op->addParserOutput( $pOut2 );
$this->assertFalse( $op->forceHideNewSectionLink() );
// Note that flags are OR'ed together, and not reset.
$this->assertTrue( $op->getOutputFlag( ParserOutputFlags::HIDE_NEW_SECTION ) );
}
public function testSetSyndicated() {
$op = $this->newInstance( [ MainConfigNames::Feed => true ] );
$this->assertFalse( $op->isSyndicated() );
$op->setSyndicated();
$this->assertTrue( $op->isSyndicated() );
$op->setSyndicated( false );
$this->assertFalse( $op->isSyndicated() );
$op = $this->newInstance(); // Feed => false by default
$this->assertFalse( $op->isSyndicated() );
$op->setSyndicated();
$this->assertFalse( $op->isSyndicated() );
}
public function testFeedLinks() {
$op = $this->newInstance( [ MainConfigNames::Feed => true ] );
$this->assertSame( [], $op->getSyndicationLinks() );
$op->addFeedLink( 'not a supported format', 'abc' );
$this->assertFalse( $op->isSyndicated() );
$this->assertSame( [], $op->getSyndicationLinks() );
$feedTypes = $op->getConfig()->get( MainConfigNames::AdvertisedFeedTypes );
$op->addFeedLink( $feedTypes[0], 'def' );
$this->assertTrue( $op->isSyndicated() );
$this->assertSame( [ $feedTypes[0] => 'def' ], $op->getSyndicationLinks() );
$op->setFeedAppendQuery( false );
$expected = [];
foreach ( $feedTypes as $type ) {
$expected[$type] = $op->getTitle()->getLocalURL( "feed=$type" );
}
$this->assertSame( $expected, $op->getSyndicationLinks() );
$op->setFeedAppendQuery( 'apples=oranges' );
foreach ( $feedTypes as $type ) {
$expected[$type] = $op->getTitle()->getLocalURL( "feed=$type&apples=oranges" );
}
$this->assertSame( $expected, $op->getSyndicationLinks() );
$op = $this->newInstance(); // Feed => false by default
$this->assertSame( [], $op->getSyndicationLinks() );
$op->addFeedLink( $feedTypes[0], 'def' );
$this->assertFalse( $op->isSyndicated() );
$this->assertSame( [], $op->getSyndicationLinks() );
}
public function testArticleFlags() {
$op = $this->newInstance();
$this->assertFalse( $op->isArticle() );
$this->assertTrue( $op->isArticleRelated() );
$op->setArticleRelated( false );
$this->assertFalse( $op->isArticle() );
$this->assertFalse( $op->isArticleRelated() );
$op->setArticleFlag( true );
$this->assertTrue( $op->isArticle() );
$this->assertTrue( $op->isArticleRelated() );
$op->setArticleFlag( false );
$this->assertFalse( $op->isArticle() );
$this->assertTrue( $op->isArticleRelated() );
$op->setArticleFlag( true );
$op->setArticleRelated( false );
$this->assertFalse( $op->isArticle() );
$this->assertFalse( $op->isArticleRelated() );
}
public function testLanguageLinks() {
$op = $this->newInstance();
$this->assertSame( [], $op->getLanguageLinks() );
$op->addLanguageLinks( [ 'fr:A#x', 'it:B' ] );
$this->assertSame( [ 'fr:A#x', 'it:B' ], $op->getLanguageLinks() );
$op->addLanguageLinks( [
TitleValue::tryNew( NS_MAIN, 'C', '', 'de' ),
TitleValue::tryNew( NS_MAIN, 'D', '', 'es' ),
] );
$this->assertSame( [ 'fr:A#x', 'it:B', 'de:C', 'es:D' ], $op->getLanguageLinks() );
$op->setLanguageLinks( [ TitleValue::tryNew( NS_MAIN, 'E', '', 'pt' ) ] );
$this->assertSame( [ 'pt:E' ], $op->getLanguageLinks() );
$pOut1 = $this->createParserOutputStub( 'getLanguageLinks', [ 'he:F', 'ar:G#y' ] );
$op->addParserOutputMetadata( $pOut1 );
$this->assertSame( [ 'pt:E', 'he:F', 'ar:G#y' ], $op->getLanguageLinks() );
# Duplicates are removed in OutputPage (T26502)
$pOut2 = $this->createParserOutputStub( 'getLanguageLinks', [ 'pt:H' ] );
$op->addParserOutput( $pOut2 );
$this->assertSame( [ 'pt:E', 'he:F', 'ar:G#y' ], $op->getLanguageLinks() );
}
// @todo Are these category links tests too abstract and complicated for what they test? Would
// it make sense to just write out all the tests by hand with maybe some copy-and-paste?
/**
* @dataProvider provideGetCategories
*
*
* @param array $args Array of form [ category name => sort key ]
* @param array $fakeResults Array of form [ category name => value to return from mocked
* LinkBatch ]
* @param callable|null $variantLinkCallback Callback to replace findVariantLink() call
* @param array $expectedNormal Expected return value of getCategoryLinks['normal']
* @param array $expectedHidden Expected return value of getCategoryLinks['hidden']
*/
public function testAddCategoryLinks(
array $args, array $fakeResults, ?callable $variantLinkCallback,
array $expectedNormal, array $expectedHidden
) {
$expectedNormal = $this->extractExpectedCategories( $expectedNormal, 'add' );
$expectedHidden = $this->extractExpectedCategories( $expectedHidden, 'add' );
$op = $this->setupCategoryTests( $fakeResults, $variantLinkCallback );
$op->addCategoryLinks( $args );
$this->doCategoryAsserts( $op, $expectedNormal, $expectedHidden );
$this->doCategoryLinkAsserts( $op, $expectedNormal, $expectedHidden );
}
/**
* @dataProvider provideGetCategories
*/
public function testAddCategoryLinksOneByOne(
array $args, array $fakeResults, ?callable $variantLinkCallback,
array $expectedNormal, array $expectedHidden
) {
if ( count( $args ) <= 1 ) {
// @todo Should this be skipped instead of passed?
$this->assertTrue( true );
return;
}
$expectedNormal = $this->extractExpectedCategories( $expectedNormal, 'onebyone' );
$expectedHidden = $this->extractExpectedCategories( $expectedHidden, 'onebyone' );
$op = $this->setupCategoryTests( $fakeResults, $variantLinkCallback );
foreach ( $args as $key => $val ) {
$op->addCategoryLinks( [ $key => $val ] );
}
$this->doCategoryAsserts( $op, $expectedNormal, $expectedHidden );
$this->doCategoryLinkAsserts( $op, $expectedNormal, $expectedHidden );
}
/**
* @dataProvider provideGetCategories
*/
public function testSetCategoryLinks(
array $args, array $fakeResults, ?callable $variantLinkCallback,
array $expectedNormal, array $expectedHidden
) {
$expectedNormal = $this->extractExpectedCategories( $expectedNormal, 'set' );
$expectedHidden = $this->extractExpectedCategories( $expectedHidden, 'set' );
$op = $this->setupCategoryTests( $fakeResults, $variantLinkCallback );
$this->filterDeprecated( '/OutputPage::setCategoryLinks was deprecated/' );
$op->setCategoryLinks( [ 'Initial page' => 'Initial page' ] );
$op->setCategoryLinks( $args );
// We don't reset the categories, for some reason, only the links
$expectedNormalCats = array_merge( [ 'Initial page' ], $expectedNormal );
$this->doCategoryAsserts( $op, $expectedNormalCats, $expectedHidden );
$this->doCategoryLinkAsserts( $op, $expectedNormal, $expectedHidden );
}
/**
* @dataProvider provideGetCategories
*/
public function testParserOutputCategoryLinks(
array $args, array $fakeResults, ?callable $variantLinkCallback,
array $expectedNormal, array $expectedHidden
) {
$expectedNormal = $this->extractExpectedCategories( $expectedNormal, 'pout' );
$expectedHidden = $this->extractExpectedCategories( $expectedHidden, 'pout' );
$op = $this->setupCategoryTests( $fakeResults, $variantLinkCallback );
$stubPO = $this->createParserOutputStub( [
'getCategoryMap' => $args,
] );
// addParserOutput and addParserOutputMetadata should behave identically for us, so
// alternate to get coverage for both without adding extra tests
static $idx = 0;
$idx++;
$method = [ 'addParserOutputMetadata', 'addParserOutput' ][$idx % 2];
$op->$method( $stubPO );
$this->doCategoryAsserts( $op, $expectedNormal, $expectedHidden );
$this->doCategoryLinkAsserts( $op, $expectedNormal, $expectedHidden );
}
/**
* @dataProvider provideGetCategories
*/
public function testOutputPageRenderCategoryLinkHook(
array $args, array $fakeResults, ?callable $variantLinkCallback,
array $expectedNormal, array $expectedHidden, array $expectedText
) {
$expectedNormal = $this->extractExpectedCategories( $expectedNormal, 'add' );
$expectedHidden = $this->extractExpectedCategories( $expectedHidden, 'add' );
$op = $this->setupCategoryTests( $fakeResults, $variantLinkCallback );
$tf = $this->getServiceContainer()->getTitleFormatter();
$this->setTemporaryHook( 'OutputPageRenderCategoryLink',
static function ( $outputPage, $categoryTitle, $text, &$link ) use ( $tf ) {
$link = 'Custom link: ' . $tf->getPrefixedText( $categoryTitle ) . ", text: ($text)";
}
);
$op->addCategoryLinks( $args );
$this->doCategoryAsserts( $op, $expectedNormal, $expectedHidden );
$this->doCategoryLinkAsserts( $op, $expectedNormal, $expectedHidden );
$i = 0;
foreach ( $op->getCategoryLinks() as $type => $actual ) {
foreach ( $actual as $link ) {
$text = $expectedText[$i++];
$this->assertStringContainsString( 'Custom link: Category:', $link );
$this->assertStringContainsString( ", text: ($text)", $link );
}
}
$this->assertCount( $i, $expectedText );
}
/**
* We allow different expectations for different tests as an associative array, like
* [ 'set' => [ ... ], 'default' => [ ... ] ] if setCategoryLinks() will give a different
* result.
* @param array $expected
* @param string $key
* @return array
*/
private function extractExpectedCategories( array $expected, $key ) {
if ( !$expected || isset( $expected[0] ) ) {
return $expected;
}
return $expected[$key] ?? $expected['default'];
}
private function setupCategoryTests(
array $fakeResults, ?callable $variantLinkCallback = null
): OutputPage {
$this->overrideConfigValue( MainConfigNames::UsePigLatinVariant, true );
if ( $variantLinkCallback ) {
$mockLanguageConverter = $this
->createMock( ILanguageConverter::class );
$mockLanguageConverter
->method( 'findVariantLink' )
->willReturnCallback( $variantLinkCallback );
$mockLanguageConverter
->method( 'convertHtml' )
->willReturnCallback( 'strrev' );
$languageConverterFactory = $this
->createMock( LanguageConverterFactory::class );
$languageConverterFactory
->method( 'getLanguageConverter' )
->willReturn( $mockLanguageConverter );
$this->setService(
'LanguageConverterFactory',
$languageConverterFactory
);
}
$op = $this->getMockBuilder( OutputPage::class )
->setConstructorArgs( [ new RequestContext() ] )
->onlyMethods( [ 'addCategoryLinksToLBAndGetResult', 'getTitle' ] )
->getMock();
$title = Title::makeTitle( NS_MAIN, 'My test page' );
$op->method( 'getTitle' )
->willReturn( $title );
$op->method( 'addCategoryLinksToLBAndGetResult' )
->willReturnCallback( static function ( array $categories ) use ( $fakeResults ) {
$return = [];
foreach ( $categories as $category => $unused ) {
if ( isset( $fakeResults[$category] ) ) {
$return[] = $fakeResults[$category];
}
}
return new FakeResultWrapper( $return );
} );
$this->assertSame( [], $op->getCategories() );
return $op;
}
private function doCategoryAsserts( OutputPage $op, $expectedNormal, $expectedHidden ) {
$this->assertSame( array_merge( $expectedHidden, $expectedNormal ), $op->getCategories() );
$this->assertSame( $expectedNormal, $op->getCategories( 'normal' ) );
$this->assertSame( $expectedHidden, $op->getCategories( 'hidden' ) );
}
private function doCategoryLinkAsserts( OutputPage $op, $expectedNormal, $expectedHidden ) {
$catLinks = $op->getCategoryLinks();
$this->assertCount( (bool)$expectedNormal + (bool)$expectedHidden, $catLinks );
if ( $expectedNormal ) {
$this->assertSameSize( $expectedNormal, $catLinks['normal'] );
}
if ( $expectedHidden ) {
$this->assertSameSize( $expectedHidden, $catLinks['hidden'] );
}
foreach ( $expectedNormal as $i => $name ) {
$this->assertStringContainsString( $name, $catLinks['normal'][$i] );
}
foreach ( $expectedHidden as $i => $name ) {
$this->assertStringContainsString( $name, $catLinks['hidden'][$i] );
}
}
public static function provideGetCategories() {
return [
'No categories' => [ [], [], null, [], [], [] ],
'Simple test' => [
[ 'Test1' => 'Some sortkey', 'Test2' => 'A different sortkey' ],
[ 'Test1' => (object)[ 'pp_value' => 1, 'page_title' => 'Test1' ],
'Test2' => (object)[ 'page_title' => 'Test2' ] ],
null,
[ 'Test2' ],
[ 'Test1' ],
[ 'Test1', 'Test2' ],
],
'Invalid title' => [
[ '[' => '[', 'Test' => 'Test' ],
[ 'Test' => (object)[ 'page_title' => 'Test' ] ],
null,
[ 'Test' ],
[],
[ 'Test' ],
],
'Variant link' => [
[ 'Test' => 'Test', 'Estay' => 'Estay' ],
[ 'Test' => (object)[ 'page_title' => 'Test' ] ],
static function ( &$link, &$title ) {
if ( $link === 'Estay' ) {
$link = 'Test';
$title = Title::makeTitleSafe( NS_CATEGORY, $link );
}
},
// For adding one by one, the variant gets added as well as the original category,
// but if you add them all together the second time gets skipped.
[ 'onebyone' => [ 'Test', 'Test' ], 'default' => [ 'Test' ] ],
[],
[ 'tseT' ],
],
];
}
public function testGetCategoriesInvalid() {
$this->expectException( InvalidArgumentException::class );
$this->expectExceptionMessage( 'Invalid category type given: hiddne' );
$op = $this->newInstance();
$op->getCategories( 'hiddne' );
}
// @todo Should we test addCategoryLinksToLBAndGetResult? If so, how? Insert some test rows in
// the DB?
public function testIndicators() {
$op = $this->newInstance();
$this->assertSame( [], $op->getIndicators() );
$op->setIndicators( [] );
$this->assertSame( [], $op->getIndicators() );
// Test sorting alphabetically
$op->setIndicators( [ 'b' => 'x', 'a' => 'y' ] );
$this->assertSame( [ 'a' => 'y', 'b' => 'x' ], $op->getIndicators() );
// Test overwriting existing keys
$op->setIndicators( [ 'c' => 'z', 'a' => 'w' ] );
$this->assertSame( [ 'a' => 'w', 'b' => 'x', 'c' => 'z' ], $op->getIndicators() );
// Test with addParserOutputMetadata
// Note that the indicators are wrapped.
$pOut1 = $this->createParserOutputStub( [
'getIndicators' => [ 'c' => 'u', 'd' => 'v' ],
'getWrapperDivClass' => 'wrapper1',
] );
$op->addParserOutputMetadata( $pOut1 );
$this->assertSame( [
'a' => 'w',
'b' => 'x',
'c' => '<div class="wrapper1">u</div>',
'd' => '<div class="wrapper1">v</div>',
], $op->getIndicators() );
// Test with addParserOutput
$pOut2 = $this->createParserOutputStub( [
'getIndicators' => [ 'a' => '!!!' ],
'getWrapperDivClass' => 'wrapper2',
] );
$op->addParserOutput( $pOut2 );
$this->assertSame( [
'a' => '<div class="wrapper2">!!!</div>',
'b' => 'x',
'c' => '<div class="wrapper1">u</div>',
'd' => '<div class="wrapper1">v</div>',
], $op->getIndicators() );
}
public function testAddHelpLink() {
$op = $this->newInstance();
$op->addHelpLink( 'Manual:PHP unit testing' );
$indicators = $op->getIndicators();
$this->assertSame( [ 'mw-helplink' ], array_keys( $indicators ) );
$this->assertStringContainsString( 'Manual:PHP_unit_testing', $indicators['mw-helplink'] );
$op->addHelpLink( 'https://phpunit.de', true );
$indicators = $op->getIndicators();
$this->assertSame( [ 'mw-helplink' ], array_keys( $indicators ) );
$this->assertStringContainsString( 'https://phpunit.de', $indicators['mw-helplink'] );
$this->assertStringNotContainsString( 'mediawiki', $indicators['mw-helplink'] );
$this->assertStringNotContainsString( 'Manual:PHP', $indicators['mw-helplink'] );
}
public function testBodyHTML() {
$op = $this->newInstance();
$this->assertSame( '', $op->getHTML() );
$op->addHTML( 'a' );
$this->assertSame( 'a', $op->getHTML() );
$op->addHTML( 'b' );
$this->assertSame( 'ab', $op->getHTML() );
$op->prependHTML( 'c' );
$this->assertSame( 'cab', $op->getHTML() );
$op->addElement( 'p', [ 'id' => 'foo' ], 'd' );
$this->assertSame( 'cab<p id="foo">d</p>', $op->getHTML() );
$op->clearHTML();
$this->assertSame( '', $op->getHTML() );
}
/**
* @dataProvider provideRevisionId
*/
public function testRevisionId( $newVal, $expected ) {
$op = $this->newInstance();
$this->assertNull( $op->setRevisionId( $newVal ) );
$this->assertSame( $expected, $op->getRevisionId() );
$this->assertSame( $expected, $op->setRevisionId( null ) );
$this->assertNull( $op->getRevisionId() );
}
public static function provideRevisionId() {
return [
[ null, null ],
[ 7, 7 ],
[ -1, -1 ],
[ 3.2, 3 ],
[ '0', 0 ],
[ '32% finished', 32 ],
[ false, 0 ],
];
}
public function testRevisionTimestamp() {
$op = $this->newInstance();
$this->assertNull( $op->getRevisionTimestamp() );
$this->assertNull( $op->setRevisionTimestamp( 'abc' ) );
$this->assertSame( 'abc', $op->getRevisionTimestamp() );
$this->assertSame( 'abc', $op->setRevisionTimestamp( null ) );
$this->assertNull( $op->getRevisionTimestamp() );
}
public function testFileVersion() {
$op = $this->newInstance();
$this->assertNull( $op->getFileVersion() );
$stubFile = $this->createMock( File::class );
$stubFile->method( 'exists' )->willReturn( true );
$stubFile->method( 'getTimestamp' )->willReturn( '12211221123321' );
$stubFile->method( 'getSha1' )->willReturn( 'bf3ffa7047dc080f5855377a4f83cd18887e3b05' );
/** @var File $stubFile */
$op->setFileVersion( $stubFile );
$this->assertEquals(
[ 'time' => '12211221123321', 'sha1' => 'bf3ffa7047dc080f5855377a4f83cd18887e3b05' ],
$op->getFileVersion()
);
$stubMissingFile = $this->createMock( File::class );
$stubMissingFile->method( 'exists' )->willReturn( false );
/** @var File $stubMissingFile */
$op->setFileVersion( $stubMissingFile );
$this->assertNull( $op->getFileVersion() );
$op->setFileVersion( $stubFile );
$this->assertNotNull( $op->getFileVersion() );
$op->setFileVersion( null );
$this->assertNull( $op->getFileVersion() );
}
/**
* Call either with arguments $methodName, $returnValue; or an array
* [ $methodName => $returnValue, $methodName => $returnValue, ... ]
* @param mixed ...$args
* @return ParserOutput
*/
private function createParserOutputStub( ...$args ): ParserOutput {
if ( count( $args ) === 0 ) {
$retVals = [];
} elseif ( count( $args ) === 1 ) {
$retVals = $args[0];
} elseif ( count( $args ) === 2 ) {
$retVals = [ $args[0] => $args[1] ];
}
return $this->createParserOutputStubWithFlags( $retVals, [] );
}
/**
* First argument is an array
* [ $methodName => $returnValue, $methodName => $returnValue, ... ]
* Second argument is an array of parser flags for which ::getOutputFlag()
* should return 'TRUE'.
* @param array $retVals
* @param array $flags
* @return ParserOutput
*/
private function createParserOutputStubWithFlags( array $retVals, array $flags ): ParserOutput {
$pOut = $this->createMock( ParserOutput::class );
$mockedRunOutputPipeline = false;
foreach ( $retVals as $method => $retVal ) {
$pOut->method( $method )->willReturn( $retVal );
if ( $method === 'runOutputPipeline' ) {
$mockedRunOutputPipeline = true;
}
}
// Needed to ensure OutputPage::getParserOutputText doesn't return null
if ( !$mockedRunOutputPipeline ) {
$pOut->method( 'runOutputPipeline' )->willReturn( new ParserOutput( '' ) );
}
$arrayReturningMethods = [
'getCategoryMap',
'getFileSearchOptions',
'getHeadItems',
'getImages',
'getIndicators',
'getSections',
'getLanguageLinks',
'getTemplateIds',
'getExtraCSPDefaultSrcs',
'getExtraCSPStyleSrcs',
'getExtraCSPScriptSrcs',
];
foreach ( $arrayReturningMethods as $method ) {
$pOut->method( $method )->willReturn( [] );
}
$pOut->method( 'getOutputFlag' )->willReturnCallback( static function ( $name ) use ( $flags ) {
return in_array( $name, $flags, true );
} );
return $pOut;
}
public function testTemplateIds() {
$op = $this->newInstance();
$this->assertSame( [], $op->getTemplateIds() );
// Test with no template id's
$stubPOEmpty = $this->createParserOutputStub();
$op->addParserOutputMetadata( $stubPOEmpty );
$this->assertSame( [], $op->getTemplateIds() );
// Test with some arbitrary template id's
$ids = [
NS_MAIN => [ 'A' => 3, 'B' => 17 ],
NS_TALK => [ 'C' => 31 ],
NS_MEDIA => [ 'D' => -1 ],
];
$stubPO1 = $this->createParserOutputStub( 'getTemplateIds', $ids );
$op->addParserOutputMetadata( $stubPO1 );
$this->assertSame( $ids, $op->getTemplateIds() );
// Test merging with a second set of id's
$stubPO2 = $this->createParserOutputStub( 'getTemplateIds', [
NS_MAIN => [ 'E' => 1234 ],
NS_PROJECT => [ 'F' => 5678 ],
] );
$finalIds = [
NS_MAIN => [ 'E' => 1234, 'A' => 3, 'B' => 17 ],
NS_TALK => [ 'C' => 31 ],
NS_MEDIA => [ 'D' => -1 ],
NS_PROJECT => [ 'F' => 5678 ],
];
$op->addParserOutput( $stubPO2 );
$this->assertSame( $finalIds, $op->getTemplateIds() );
// Test merging with an empty set of id's
$op->addParserOutputMetadata( $stubPOEmpty );
$this->assertSame( $finalIds, $op->getTemplateIds() );
}
public function testFileSearchOptions() {
$op = $this->newInstance();
$this->assertSame( [], $op->getFileSearchOptions() );
// Test with no files
$stubPOEmpty = $this->createParserOutputStub();
$op->addParserOutputMetadata( $stubPOEmpty );
$this->assertSame( [], $op->getFileSearchOptions() );
// Test with some arbitrary files
$files1 = [
'A' => [ 'time' => null, 'sha1' => '' ],
'B' => [
'time' => '12211221123321',
'sha1' => 'bf3ffa7047dc080f5855377a4f83cd18887e3b05',
],
];
$stubPO1 = $this->createParserOutputStub( 'getFileSearchOptions', $files1 );
$op->addParserOutput( $stubPO1 );
$this->assertSame( $files1, $op->getFileSearchOptions() );
// Test merging with a second set of files
$files2 = [
'C' => [ 'time' => null, 'sha1' => '' ],
'B' => [ 'time' => null, 'sha1' => '' ],
];
$stubPO2 = $this->createParserOutputStub( 'getFileSearchOptions', $files2 );
$op->addParserOutputMetadata( $stubPO2 );
$this->assertSame( array_merge( $files1, $files2 ), $op->getFileSearchOptions() );
// Test merging with an empty set of files
$op->addParserOutput( $stubPOEmpty );
$this->assertSame( array_merge( $files1, $files2 ), $op->getFileSearchOptions() );
}
/**
* @dataProvider provideAddWikiText
*/
public function testAddWikiText( $method, array $args, $expected ) {
$op = $this->newInstance();
$this->assertSame( '', $op->getHTML() );
if ( in_array(
$method,
[ 'addWikiTextAsInterface', 'addWikiTextAsContent' ]
) && count( $args ) >= 3 && $args[2] === null ) {
// Special placeholder because we can't get the actual title in the provider
$args[2] = $op->getTitle();
}
$op->$method( ...$args );
$this->assertSame( $expected, $op->getHTML() );
}
public static function provideAddWikiText() {
$somePageRef = new PageReferenceValue( NS_TALK, 'Some page', PageReference::LOCAL );
$tests = [
'addWikiTextAsInterface' => [
'Simple wikitext' => [
[ "'''Bold'''" ],
"<p><b>Bold</b>\n</p>",
], 'Untidy wikitext' => [
[ "<b>Bold" ],
"<p><b>Bold\n</b></p>",
], 'List at start' => [
[ '* List' ],
"<ul><li>List</li></ul>\n",
], 'List not at start' => [
[ '* Not a list', false ],
'<p>* Not a list</p>',
], 'No section edit links' => [
[ '== Title ==' ],
'<div class="mw-heading mw-heading2"><h2 id="Title">Title</h2></div>',
], 'With title at start' => [
[ '* {{PAGENAME}}', true, Title::makeTitle( NS_TALK, 'Some page' ) ],
"<ul><li>Some page</li></ul>\n",
], 'With title not at start' => [
[ '* {{PAGENAME}}', false, Title::makeTitle( NS_TALK, 'Some page' ) ],
"<p>* Some page</p>",
], 'Untidy input' => [
[ '<b>{{PAGENAME}}', true, $somePageRef ],
"<p><b>Some page\n</b></p>",
],
],
'addWikiTextAsContent' => [
'SpecialNewimages' => [
[ "<p lang='en' dir='ltr'>\nMy message" ],
'<p lang="en" dir="ltr">' . "\nMy message</p>"
], 'List at start' => [
[ '* List' ],
"<ul><li>List</li></ul>",
], 'List not at start' => [
[ '* <b>Not a list', false ],
'<p>* <b>Not a list</b></p>',
], 'With title at start' => [
[ '* {{PAGENAME}}', true, Title::makeTitle( NS_TALK, 'Some page' ) ],
"<ul><li>Some page</li></ul>",
], 'With title not at start' => [
[ '* {{PAGENAME}}', false, Title::makeTitle( NS_TALK, 'Some page' ) ],
"<p>* Some page</p>",
], 'EditPage' => [
[ "<div class='mw-editintro'>{{PAGENAME}}", true, $somePageRef ],
'<div class="mw-editintro">' . "Some page</div>"
],
],
'wrapWikiTextAsInterface' => [
'Simple' => [
[ 'wrapperClass', 'text' ],
"<div class=\"mw-content-ltr wrapperClass\" lang=\"en\" dir=\"ltr\"><p>text\n</p></div>"
], 'Spurious </div>' => [
[ 'wrapperClass', 'text</div><div>more' ],
"<div class=\"mw-content-ltr wrapperClass\" lang=\"en\" dir=\"ltr\"><p>text</p><div>more</div></div>"
], 'Extra newlines would break <p> wrappers' => [
[ 'two classes', "1\n\n2\n\n3" ],
"<div class=\"mw-content-ltr two classes\" lang=\"en\" dir=\"ltr\"><p>1\n</p><p>2\n</p><p>3\n</p></div>"
], 'Other unclosed tags' => [
[ 'error', 'a<b>c<i>d' ],
"<div class=\"mw-content-ltr error\" lang=\"en\" dir=\"ltr\"><p>a<b>c<i>d\n</i></b></p></div>"
],
],
];
// We have to reformat our array to match what PHPUnit wants
$ret = [];
foreach ( $tests as $key => $subarray ) {
foreach ( $subarray as $subkey => $val ) {
$val = array_merge( [ $key ], $val );
$ret[$subkey] = $val;
}
}
return $ret;
}
public function testAddWikiTextAsInterfaceNoTitle() {
$this->expectException( RuntimeException::class );
$this->expectExceptionMessage( 'No title' );
$op = $this->newInstance( [], null, 'notitle' );
$op->addWikiTextAsInterface( 'a' );
}
public function testAddWikiTextAsContentNoTitle() {
$this->expectException( RuntimeException::class );
$this->expectExceptionMessage( 'No title' );
$op = $this->newInstance( [], null, 'notitle' );
$op->addWikiTextAsContent( 'a' );
}
public function testAddWikiMsg() {
$msg = wfMessage( 'parentheses' );
$this->assertSame( '(a)', $msg->rawParams( 'a' )->plain() );
$op = $this->newInstance();
$this->assertSame( '', $op->getHTML() );
$op->addWikiMsg( 'parentheses', "<b>a" );
// The input is bad unbalanced HTML, but the output is tidied
$this->assertSame( "<p>(<b>a)\n</b></p>", $op->getHTML() );
}
public function testWrapWikiMsg() {
$msg = wfMessage( 'parentheses' );
$this->assertSame( '(a)', $msg->rawParams( 'a' )->plain() );
$op = $this->newInstance();
$this->assertSame( '', $op->getHTML() );
$op->wrapWikiMsg( '[$1]', [ 'parentheses', "<b>a" ] );
// The input is bad unbalanced HTML, but the output is tidied
$this->assertSame( "<p>[(<b>a)]\n</b></p>", $op->getHTML() );
}
public function testNoGallery() {
$op = $this->newInstance();
$this->assertFalse( $op->getNoGallery() );
$this->assertFalse( $op->getOutputFlag( ParserOutputFlags::NO_GALLERY ) );
$stubPO1 = $this->createParserOutputStubWithFlags(
[ 'getNoGallery' => true ], [ ParserOutputFlags::NO_GALLERY ]
);
$op->addParserOutputMetadata( $stubPO1 );
$this->assertTrue( $op->getNoGallery() );
$this->assertTrue( $op->getOutputFlag( ParserOutputFlags::NO_GALLERY ) );
$stubPO2 = $this->createParserOutputStub( 'getNoGallery', false );
$op->addParserOutput( $stubPO2 );
$this->assertFalse( $op->getNoGallery() );
// Note that flags are OR'ed together, and not reset.
$this->assertTrue( $op->getOutputFlag( ParserOutputFlags::NO_GALLERY ) );
}
// @todo Make sure to test the following in addParserOutputMetadata() as well when we add tests
// for them:
// * addModules()
// * addModuleStyles()
// * addJsConfigVars()
// * enableOOUI()
// Otherwise those lines of addParserOutputMetadata() will be reported as covered, but we won't
// be testing they actually work.
public function testAddParserOutputText() {
$op = $this->newInstance();
$this->assertSame( '', $op->getHTML() );
$text = '<some text>';
$pOut = $this->createParserOutputStub( 'runOutputPipeline', new ParserOutput( $text ) );
$op->addParserOutputMetadata( $pOut );
$this->assertSame( '', $op->getHTML() );
$op->addParserOutputText( $text );
$this->assertSame( '<some text>', $op->getHTML() );
}
public function testAddParserOutput() {
$op = $this->newInstance();
$this->assertSame( '', $op->getHTML() );
$this->assertFalse( $op->showNewSectionLink() );
$this->assertFalse( $op->getOutputFlag( ParserOutputFlags::NEW_SECTION ) );
$pOut = $this->createParserOutputStubWithFlags( [
'getContentHolderText' => '<some text>',
'getNewSection' => true,
], [
ParserOutputFlags::NEW_SECTION,
] );
$op->addParserOutput( $pOut );
$this->assertSame( '<some text>', $op->getHTML() );
$this->assertTrue( $op->showNewSectionLink() );
$this->assertTrue( $op->getOutputFlag( ParserOutputFlags::NEW_SECTION ) );
}
public function testAddTemplate() {
$template = $this->createMock( QuickTemplate::class );
$template->method( 'getHTML' )->willReturn( '<abc>&def;' );
$op = $this->newInstance();
$op->addTemplate( $template );
$this->assertSame( '<abc>&def;', $op->getHTML() );
}
/**
* @dataProvider provideParseAs
*/
public function testParseAsContent(
array $args, $expectedHTML, $expectedHTMLInline = null
) {
$op = $this->newInstance();
$this->assertSame( $expectedHTML, $op->parseAsContent( ...$args ) );
}
/**
* @dataProvider provideParseAs
*/
public function testParseAsInterface(
array $args, $expectedHTML, $expectedHTMLInline = null
) {
$op = $this->newInstance();
$this->assertSame( $expectedHTML, $op->parseAsInterface( ...$args ) );
}
/**
* @dataProvider provideParseAs
*/
public function testParseInlineAsInterface(
array $args, $expectedHTML, $expectedHTMLInline = null
) {
$op = $this->newInstance();
$this->assertSame(
$expectedHTMLInline ?? $expectedHTML,
$op->parseInlineAsInterface( ...$args )
);
}
public static function provideParseAs() {
return [
'List at start of line' => [
[ '* List', true ],
"<ul><li>List</li></ul>",
],
'List not at start' => [
[ "* ''Not'' list", false ],
'<p>* <i>Not</i> list</p>',
'* <i>Not</i> list',
],
'Italics' => [
[ "''Italic''", true ],
"<p><i>Italic</i>\n</p>",
'<i>Italic</i>',
],
'formatnum' => [
[ '{{formatnum:123456.789}}', true ],
"<p>123,456.789\n</p>",
"123,456.789",
],
'No section edit links' => [
[ '== Header ==' ],
'<div class="mw-heading mw-heading2"><h2 id="Header">Header</h2></div>',
]
];
}
public function testParseAsContentNullTitle() {
$this->expectException( RuntimeException::class );
$this->expectExceptionMessage( 'No title' );
$op = $this->newInstance( [], null, 'notitle' );
$op->parseAsContent( '' );
}
public function testParseAsInterfaceNullTitle() {
$this->expectException( RuntimeException::class );
$this->expectExceptionMessage( 'No title' );
$op = $this->newInstance( [], null, 'notitle' );
$op->parseAsInterface( '' );
}
public function testParseInlineAsInterfaceNullTitle() {
$this->expectException( RuntimeException::class );
$this->expectExceptionMessage( 'No title' );
$op = $this->newInstance( [], null, 'notitle' );
$op->parseInlineAsInterface( '' );
}
public function testCdnMaxage() {
$op = $this->newInstance();
$wrapper = TestingAccessWrapper::newFromObject( $op );
$this->assertSame( 0, $wrapper->mCdnMaxage );
$op->setCdnMaxage( -1 );
$this->assertSame( -1, $wrapper->mCdnMaxage );
$op->setCdnMaxage( 120 );
$this->assertSame( 120, $wrapper->mCdnMaxage );
$op->setCdnMaxage( 60 );
$this->assertSame( 60, $wrapper->mCdnMaxage );
$op->setCdnMaxage( 180 );
$this->assertSame( 180, $wrapper->mCdnMaxage );
$op->lowerCdnMaxage( 240 );
$this->assertSame( 180, $wrapper->mCdnMaxage );
$op->setCdnMaxage( 300 );
$this->assertSame( 240, $wrapper->mCdnMaxage );
$op->lowerCdnMaxage( 120 );
$this->assertSame( 120, $wrapper->mCdnMaxage );
$op->setCdnMaxage( 180 );
$this->assertSame( 120, $wrapper->mCdnMaxage );
$op->setCdnMaxage( 60 );
$this->assertSame( 60, $wrapper->mCdnMaxage );
$op->setCdnMaxage( 240 );
$this->assertSame( 120, $wrapper->mCdnMaxage );
}
/** @var int Faked time to set for tests that need it */
private static $fakeTime;
/**
* @dataProvider provideAdaptCdnTTL
* @param array $args To pass to adaptCdnTTL()
* @param int $expected Expected new value of mCdnMaxageLimit
* @param array $options Associative array:
* initialMaxage => Maxage to set before calling adaptCdnTTL() (default 86400)
*/
public function testAdaptCdnTTL( array $args, $expected, array $options = [] ) {
MWTimestamp::setFakeTime( self::$fakeTime );
$op = $this->newInstance();
// Set a high maxage so that it will get reduced by adaptCdnTTL(). The default maxage
// is 0, so adaptCdnTTL() won't mutate the object at all.
$initial = $options['initialMaxage'] ?? 86400;
$op->setCdnMaxage( $initial );
$op->adaptCdnTTL( ...$args );
$wrapper = TestingAccessWrapper::newFromObject( $op );
// Special rules for false/null
if ( $args[0] === null || $args[0] === false ) {
$this->assertSame( $initial, $wrapper->mCdnMaxage, 'member value' );
$op->setCdnMaxage( $expected + 1 );
$this->assertSame( $expected + 1, $wrapper->mCdnMaxage, 'member value after new set' );
return;
}
$this->assertSame( $expected, $wrapper->mCdnMaxageLimit, 'limit value' );
if ( $initial >= $expected ) {
$this->assertSame( $expected, $wrapper->mCdnMaxage, 'member value' );
} else {
$this->assertSame( $initial, $wrapper->mCdnMaxage, 'member value' );
}
$op->setCdnMaxage( $expected + 1 );
$this->assertSame( $expected, $wrapper->mCdnMaxage, 'member value after new set' );
}
public static function provideAdaptCdnTTL() {
global $wgCdnMaxAge;
$now = time();
self::$fakeTime = $now;
return [
'Five minutes ago' => [ [ $now - 300 ], 270 ],
'Now' => [ [ +0 ], ExpirationAwareness::TTL_MINUTE ],
'Five minutes from now' => [ [ $now + 300 ], ExpirationAwareness::TTL_MINUTE ],
'Five minutes ago, initial maxage four minutes' =>
[ [ $now - 300 ], 270, [ 'initialMaxage' => 240 ] ],
'A very long time ago' => [ [ $now - 1000000000 ], $wgCdnMaxAge ],
'Initial maxage zero' => [ [ $now - 300 ], 270, [ 'initialMaxage' => 0 ] ],
'false' => [ [ false ], ExpirationAwareness::TTL_MINUTE ],
'null' => [ [ null ], ExpirationAwareness::TTL_MINUTE ],
"'0'" => [ [ '0' ], ExpirationAwareness::TTL_MINUTE ],
'Empty string' => [ [ '' ], ExpirationAwareness::TTL_MINUTE ],
// @todo These give incorrect results due to timezones, how to test?
//"'now'" => [ [ 'now' ], ExpirationAwareness::TTL_MINUTE ],
//"'parse error'" => [ [ 'parse error' ], ExpirationAwareness::TTL_MINUTE ],
'Now, minTTL 0' => [ [ $now, 0 ], ExpirationAwareness::TTL_MINUTE ],
'Now, minTTL 0.000001' => [ [ $now, 0.000001 ], 0 ],
'A very long time ago, maxTTL even longer' =>
[ [ $now - 1000000000, 0, 1000000001 ], 900000000 ],
];
}
public function testClientCache() {
$op = $this->newInstance();
$op->considerCacheSettingsFinal();
// Test initial value
$this->assertSame( true, $op->couldBePublicCached() );
// Test setting to false
$op->disableClientCache();
$this->assertSame( false, $op->couldBePublicCached() );
// Test setting to true
$op->enableClientCache();
$this->assertSame( true, $op->couldBePublicCached() );
// set back to false
$op->disableClientCache();
// Test that a cacheable ParserOutput doesn't set to true
$pOutCacheable = $this->createParserOutputStub( 'isCacheable', true );
$op->addParserOutputMetadata( $pOutCacheable );
$this->assertSame( false, $op->couldBePublicCached() );
// Reset to true
$op = $this->newInstance();
$op->considerCacheSettingsFinal();
$this->assertSame( true, $op->couldBePublicCached() );
// Test that an uncacheable ParserOutput does set to false
$pOutUncacheable = $this->createParserOutputStub( 'isCacheable', false );
$op->addParserOutput( $pOutUncacheable );
$this->assertSame( false, $op->couldBePublicCached() );
}
public function testGetCacheVaryCookies() {
global $wgCookiePrefix, $wgDBname;
$op = $this->newInstance();
$prefix = $wgCookiePrefix !== false ? $wgCookiePrefix : $wgDBname;
$expectedCookies = [
"{$prefix}Token",
"{$prefix}LoggedOut",
"{$prefix}_session",
'forceHTTPS',
'cookie1',
'cookie2',
];
// We have to reset the cookies because getCacheVaryCookies may have already been called
TestingAccessWrapper::newFromClass( OutputPage::class )->cacheVaryCookies = null;
$this->overrideConfigValue( MainConfigNames::CacheVaryCookies, [ 'cookie1' ] );
$this->setTemporaryHook( 'GetCacheVaryCookies',
function ( $innerOP, &$cookies ) use ( $op, $expectedCookies ) {
$this->assertSame( $op, $innerOP );
$cookies[] = 'cookie2';
$this->assertSame( $expectedCookies, $cookies );
}
);
$this->assertSame( $expectedCookies, $op->getCacheVaryCookies() );
}
public function testHaveCacheVaryCookies() {
$request = new FauxRequest();
$op = $this->newInstance( [], $request );
// No cookies are set.
$this->assertFalse( $op->haveCacheVaryCookies() );
// 'Token' is present but empty, so it shouldn't count.
$request->setCookie( 'Token', '' );
$this->assertFalse( $op->haveCacheVaryCookies() );
// 'Token' present and nonempty.
$request->setCookie( 'Token', '123' );
$this->assertTrue( $op->haveCacheVaryCookies() );
}
/**
* @dataProvider provideVaryHeaders
*
*
* @param array[] $calls For each array, call addVaryHeader() with those arguments
* @param string[] $cookies Array of cookie names to vary on
* @param string $vary Text of expected Vary header (including the 'Vary: ')
*/
public function testVaryHeaders( array $calls, array $cookies, $vary ) {
// Get rid of default Vary fields
$op = $this->getMockBuilder( OutputPage::class )
->setConstructorArgs( [ new RequestContext() ] )
->onlyMethods( [ 'getCacheVaryCookies' ] )
->getMock();
$op->method( 'getCacheVaryCookies' )
->willReturn( $cookies );
TestingAccessWrapper::newFromObject( $op )->mVaryHeader = [];
foreach ( $calls as $call ) {
$op->addVaryHeader( ...$call );
}
$this->assertEquals( $vary, $op->getVaryHeader(), 'Vary:' );
}
public static function provideVaryHeaders() {
return [
'No header' => [
[],
[],
'Vary: ',
],
'Single header' => [
[
[ 'Cookie' ],
],
[],
'Vary: Cookie',
],
'Non-unique headers' => [
[
[ 'Cookie' ],
[ 'Accept-Language' ],
[ 'Cookie' ],
],
[],
'Vary: Cookie, Accept-Language',
],
'Two headers with single options' => [
// Options are deprecated since 1.34
[
[ 'Cookie', [ 'param=phpsessid' ] ],
[ 'Accept-Language', [ 'substr=en' ] ],
],
[],
'Vary: Cookie, Accept-Language',
],
'One header with multiple options' => [
// Options are deprecated since 1.34
[
[ 'Cookie', [ 'param=phpsessid', 'param=userId' ] ],
],
[],
'Vary: Cookie',
],
'Duplicate option' => [
// Options are deprecated since 1.34
[
[ 'Cookie', [ 'param=phpsessid' ] ],
[ 'Cookie', [ 'param=phpsessid' ] ],
[ 'Accept-Language', [ 'substr=en', 'substr=en' ] ],
],
[],
'Vary: Cookie, Accept-Language',
],
'Same header, different options' => [
// Options are deprecated since 1.34
[
[ 'Cookie', [ 'param=phpsessid' ] ],
[ 'Cookie', [ 'param=userId' ] ],
],
[],
'Vary: Cookie',
],
'No header, vary cookies' => [
[],
[ 'cookie1', 'cookie2' ],
'Vary: Cookie',
],
'Cookie header with option plus vary cookies' => [
// Options are deprecated since 1.34
[
[ 'Cookie', [ 'param=cookie1' ] ],
],
[ 'cookie2', 'cookie3' ],
'Vary: Cookie',
],
'Non-cookie header plus vary cookies' => [
[
[ 'Accept-Language' ],
],
[ 'cookie' ],
'Vary: Accept-Language, Cookie',
],
'Cookie and non-cookie headers plus vary cookies' => [
// Options are deprecated since 1.34
[
[ 'Cookie', [ 'param=cookie1' ] ],
[ 'Accept-Language' ],
],
[ 'cookie2' ],
'Vary: Cookie, Accept-Language',
],
];
}
public function testVaryHeaderDefault() {
$op = $this->newInstance();
$this->assertSame( 'Vary: Accept-Encoding, Cookie', $op->getVaryHeader() );
}
/**
* @dataProvider provideLinkHeaders
*/
public function testLinkHeaders( array $headers, $result ) {
$op = $this->newInstance();
foreach ( $headers as $header ) {
$op->addLinkHeader( $header );
}
$this->assertEquals( $result, $op->getLinkHeader() );
}
public static function provideLinkHeaders() {
return [
[
[],
false
],
[
[ '<https://foo/bar.jpg>;rel=preload;as=image' ],
'Link: <https://foo/bar.jpg>;rel=preload;as=image',
],
[
[
'<https://foo/bar.jpg>;rel=preload;as=image',
'<https://foo/baz.jpg>;rel=preload;as=image'
],
'Link: <https://foo/bar.jpg>;rel=preload;as=image,<https://foo/baz.jpg>;' .
'rel=preload;as=image',
],
];
}
/**
* @dataProvider provideAddAcceptLanguage
*/
public function testAddAcceptLanguage(
$code, array $variants, $expected, array $options = []
) {
$req = new FauxRequest( in_array( 'varianturl', $options ) ? [ 'variant' => 'x' ] : [] );
$op = $this->newInstance( [], $req, in_array( 'notitle', $options ) ? 'notitle' : null );
if ( !in_array( 'notitle', $options ) ) {
$mockLang = $this->createMock( Language::class );
$mockLang->method( 'getCode' )->willReturn( $code );
$mockLanguageConverter = $this
->createMock( ILanguageConverter::class );
if ( in_array( 'varianturl', $options ) ) {
$mockLanguageConverter->expects( $this->never() )->method( $this->anything() );
} else {
$mockLanguageConverter->method( 'hasVariants' )->willReturn( count( $variants ) > 1 );
$mockLanguageConverter->method( 'getVariants' )->willReturn( $variants );
}
$languageConverterFactory = $this
->createMock( LanguageConverterFactory::class );
$languageConverterFactory
->method( 'getLanguageConverter' )
->willReturn( $mockLanguageConverter );
$this->setService(
'LanguageConverterFactory',
$languageConverterFactory
);
$mockTitle = $this->createMock( Title::class );
$mockTitle->method( 'getPageLanguage' )->willReturn( $mockLang );
$op->setTitle( $mockTitle );
}
// This will run addAcceptLanguage()
$op->sendCacheControl();
$this->assertSame( "Vary: $expected", $op->getVaryHeader() );
}
public static function provideAddAcceptLanguage() {
return [
'No variants' => [
'en',
[ 'en' ],
'Accept-Encoding, Cookie',
],
'One simple variant' => [
'en',
[ 'en', 'en-x-piglatin' ],
'Accept-Encoding, Cookie, Accept-Language',
],
'Multiple variants with BCP47 alternatives' => [
'zh',
[ 'zh', 'zh-hans', 'zh-cn', 'zh-tw' ],
'Accept-Encoding, Cookie, Accept-Language',
],
'No title' => [
'en',
[ 'en', 'en-x-piglatin' ],
'Accept-Encoding, Cookie',
[ 'notitle' ]
],
'Variant in URL' => [
'en',
[ 'en', 'en-x-piglatin' ],
'Accept-Encoding, Cookie',
[ 'varianturl' ]
],
];
}
public function testClickjacking() {
$op = $this->newInstance();
$this->assertTrue( $op->getPreventClickjacking() );
$op->setPreventClickjacking( false );
$this->assertFalse( $op->getPreventClickjacking() );
$op->setPreventClickjacking( true );
$this->assertTrue( $op->getPreventClickjacking() );
$op->setPreventClickjacking( false );
$this->assertFalse( $op->getPreventClickjacking() );
$pOut1 = $this->createParserOutputStub( 'getPreventClickjacking', true );
$op->addParserOutputMetadata( $pOut1 );
$this->assertTrue( $op->getPreventClickjacking() );
// The ParserOutput can't allow, only prevent
$pOut2 = $this->createParserOutputStub( 'getPreventClickjacking', false );
$op->addParserOutputMetadata( $pOut2 );
$this->assertTrue( $op->getPreventClickjacking() );
// Reset to test with addParserOutput()
$op->setPreventClickjacking( false );
$this->assertFalse( $op->getPreventClickjacking() );
$op->addParserOutput( $pOut1 );
$this->assertTrue( $op->getPreventClickjacking() );
$op->addParserOutput( $pOut2 );
$this->assertTrue( $op->getPreventClickjacking() );
}
/**
* @dataProvider provideGetFrameOptions
*/
public function testGetFrameOptions(
$breakFrames, $preventClickjacking, $editPageFrameOptions, $expected
) {
$op = $this->newInstance( [
MainConfigNames::BreakFrames => $breakFrames,
MainConfigNames::EditPageFrameOptions => $editPageFrameOptions,
] );
$op->setPreventClickjacking( $preventClickjacking );
$this->assertSame( $expected, $op->getFrameOptions() );
}
public static function provideGetFrameOptions() {
return [
'BreakFrames true' => [ true, false, false, 'DENY' ],
'Allow clickjacking locally' => [ false, false, 'DENY', false ],
'Allow clickjacking globally' => [ false, true, false, false ],
'DENY globally' => [ false, true, 'DENY', 'DENY' ],
'SAMEORIGIN' => [ false, true, 'SAMEORIGIN', 'SAMEORIGIN' ],
'BreakFrames with SAMEORIGIN' => [ true, true, 'SAMEORIGIN', 'DENY' ],
];
}
/**
* See ClientHtmlTest for full coverage.
*
* @dataProvider provideMakeResourceLoaderLink
*/
public function testMakeResourceLoaderLink( $args, $expectedHtml ) {
$this->overrideConfigValues( [
MainConfigNames::ResourceLoaderDebug => false,
MainConfigNames::LoadScript => 'http://127.0.0.1:8080/w/load.php',
MainConfigNames::CSPReportOnlyHeader => true,
] );
$class = new ReflectionClass( OutputPage::class );
$method = $class->getMethod( 'makeResourceLoaderLink' );
$method->setAccessible( true );
$ctx = new RequestContext();
$skinFactory = $this->getServiceContainer()->getSkinFactory();
$ctx->setSkin( $skinFactory->makeSkin( 'fallback' ) );
$ctx->setLanguage( 'en' );
$out = new OutputPage( $ctx );
$reflectCSP = new ReflectionClass( ContentSecurityPolicy::class );
$rl = $out->getResourceLoader();
$rl->setMessageBlobStore( $this->createMock( RL\MessageBlobStore::class ) );
$rl->setDependencyStore( $this->createMock( KeyValueDependencyStore::class ) );
$rl->register( [
'test.foo' => [
'class' => ResourceLoaderTestModule::class,
'script' => 'mw.test.foo( { a: true } );',
'styles' => '.mw-test-foo { content: "style"; }',
],
'test.bar' => [
'class' => ResourceLoaderTestModule::class,
'script' => 'mw.test.bar( { a: true } );',
'styles' => '.mw-test-bar { content: "style"; }',
],
'test.baz' => [
'class' => ResourceLoaderTestModule::class,
'script' => 'mw.test.baz( { a: true } );',
'styles' => '.mw-test-baz { content: "style"; }',
],
'test.quux' => [
'class' => ResourceLoaderTestModule::class,
'script' => 'mw.test.baz( { token: 123 } );',
'styles' => '/* pref-animate=off */ .mw-icon { transition: none; }',
'group' => 'private',
],
'test.noscript' => [
'class' => ResourceLoaderTestModule::class,
'styles' => '.stuff { color: red; }',
'group' => 'noscript',
],
'test.group.foo' => [
'class' => ResourceLoaderTestModule::class,
'script' => 'mw.doStuff( "foo" );',
'group' => 'foo',
],
'test.group.bar' => [
'class' => ResourceLoaderTestModule::class,
'script' => 'mw.doStuff( "bar" );',
'group' => 'bar',
],
] );
$links = $method->invokeArgs( $out, $args );
$actualHtml = strval( $links );
$this->assertEquals( $expectedHtml, $actualHtml );
}
public static function provideMakeResourceLoaderLink() {
return [
// Single only=scripts load
[
[ 'test.foo', RL\Module::TYPE_SCRIPTS ],
"<script>(RLQ=window.RLQ||[]).push(function(){"
. 'mw.loader.load("http://127.0.0.1:8080/w/load.php?lang=en\u0026modules=test.foo\u0026only=scripts");'
. "});</script>"
],
// Multiple only=styles load
[
[ [ 'test.baz', 'test.foo', 'test.bar' ], RL\Module::TYPE_STYLES ],
'<link rel="stylesheet" href="http://127.0.0.1:8080/w/load.php?lang=en&modules=test.bar%2Cbaz%2Cfoo&only=styles">'
],
// Private embed (only=scripts)
[
[ 'test.quux', RL\Module::TYPE_SCRIPTS ],
"<script>(RLQ=window.RLQ||[]).push(function(){"
. "mw.test.baz({token:123});\nmw.loader.state({\"test.quux\":\"ready\"});"
. "});</script>"
],
// Load private module (combined)
[
[ 'test.quux', RL\Module::TYPE_COMBINED ],
"<script>(RLQ=window.RLQ||[]).push(function(){"
. "mw.loader.impl(function(){return[\"test.quux@1b4i1\",function($,jQuery,require,module){"
. "mw.test.baz({token:123});\n"
. "},{\"css\":[\".mw-icon{transition:none}"
. "\"]}];});});</script>"
],
// Load no modules
[
[ [], RL\Module::TYPE_COMBINED ],
'',
],
// noscript group
[
[ 'test.noscript', RL\Module::TYPE_STYLES ],
'<noscript><link rel="stylesheet" href="http://127.0.0.1:8080/w/load.php?lang=en&modules=test.noscript&only=styles"></noscript>'
],
// Load two modules in separate groups
[
[ [ 'test.group.foo', 'test.group.bar' ], RL\Module::TYPE_COMBINED ],
"<script>(RLQ=window.RLQ||[]).push(function(){"
. 'mw.loader.load("http://127.0.0.1:8080/w/load.php?lang=en\u0026modules=test.group.bar");'
. 'mw.loader.load("http://127.0.0.1:8080/w/load.php?lang=en\u0026modules=test.group.foo");'
. "});</script>"
],
];
// phpcs:enable
}
/**
* @dataProvider provideBuildExemptModules
*/
public function testBuildExemptModules( array $exemptStyleModules, $expect ) {
$this->overrideConfigValues( [
MainConfigNames::ResourceLoaderDebug => false,
MainConfigNames::LoadScript => '/w/load.php',
// Stub wgCacheEpoch as it influences getVersionHash used for the
// urls in the expected HTML
MainConfigNames::CacheEpoch => '20140101000000',
] );
// Set up stubs
$ctx = new RequestContext();
$skinFactory = $this->getServiceContainer()->getSkinFactory();
$ctx->setSkin( $skinFactory->makeSkin( 'fallback' ) );
$ctx->setLanguage( 'en' );
$op = $this->getMockBuilder( OutputPage::class )
->setConstructorArgs( [ $ctx ] )
->onlyMethods( [ 'buildCssLinksArray' ] )
->getMock();
$op->method( 'buildCssLinksArray' )
->willReturn( [] );
/** @var OutputPage $op */
$rl = $op->getResourceLoader();
$rl->setMessageBlobStore( $this->createMock( RL\MessageBlobStore::class ) );
// Register custom modules
$rl->register( [
'example.site.a' => [ 'class' => ResourceLoaderTestModule::class, 'group' => 'site' ],
'example.site.b' => [ 'class' => ResourceLoaderTestModule::class, 'group' => 'site' ],
'example.user' => [ 'class' => ResourceLoaderTestModule::class, 'group' => 'user' ],
] );
$op = TestingAccessWrapper::newFromObject( $op );
$op->rlExemptStyleModules = $exemptStyleModules;
$expect = strtr( $expect, [
'{blankCombi}' => ResourceLoaderTestCase::BLANK_COMBI,
] );
$this->assertEquals(
$expect,
strval( $op->buildExemptModules() )
);
}
public static function provideBuildExemptModules() {
return [
'empty' => [
'exemptStyleModules' => [],
'',
],
'empty sets' => [
'exemptStyleModules' => [ 'site' => [], 'noscript' => [], 'private' => [], 'user' => [] ],
'',
],
'default logged-out' => [
'exemptStyleModules' => [ 'site' => [ 'site.styles' ] ],
'<meta name="ResourceLoaderDynamicStyles" content="">' . "\n" .
'<link rel="stylesheet" href="/w/load.php?lang=en&modules=site.styles&only=styles">',
],
'default logged-in' => [
'exemptStyleModules' => [ 'site' => [ 'site.styles' ], 'user' => [ 'user.styles' ] ],
'<meta name="ResourceLoaderDynamicStyles" content="">' . "\n" .
'<link rel="stylesheet" href="/w/load.php?lang=en&modules=site.styles&only=styles">' . "\n" .
'<link rel="stylesheet" href="/w/load.php?lang=en&modules=user.styles&only=styles&version=94mvi">',
],
'custom modules' => [
'exemptStyleModules' => [
'site' => [ 'site.styles', 'example.site.a', 'example.site.b' ],
'user' => [ 'user.styles', 'example.user' ],
],
'<meta name="ResourceLoaderDynamicStyles" content="">' . "\n" .
'<link rel="stylesheet" href="/w/load.php?lang=en&modules=example.site.a%2Cb&only=styles">' . "\n" .
'<link rel="stylesheet" href="/w/load.php?lang=en&modules=site.styles&only=styles">' . "\n" .
'<link rel="stylesheet" href="/w/load.php?lang=en&modules=example.user&only=styles&version={blankCombi}">' . "\n" .
'<link rel="stylesheet" href="/w/load.php?lang=en&modules=user.styles&only=styles&version=94mvi">',
],
];
// phpcs:enable
}
/**
* @dataProvider provideTransformFilePath
*/
public function testTransformResourcePath( $baseDir, $basePath, $uploadDir = null,
$uploadPath = null, $path = null, $expected = null
) {
if ( $path === null ) {
// Skip optional $uploadDir and $uploadPath
$path = $uploadDir;
$expected = $uploadPath;
$uploadDir = "$baseDir/images";
$uploadPath = "$basePath/images";
}
$conf = new HashConfig( [
MainConfigNames::ResourceBasePath => $basePath,
MainConfigNames::UploadDirectory => $uploadDir,
MainConfigNames::UploadPath => $uploadPath,
MainConfigNames::BaseDirectory => $baseDir
] );
// Some of these paths don't exist and will cause warnings
$actual = @OutputPage::transformResourcePath( $conf, $path );
$this->assertEquals( $expected ?: $path, $actual );
}
public static function provideTransformFilePath() {
$baseDir = dirname( __DIR__ ) . '/../data/media';
return [
// File that matches basePath, and exists. Hash found and appended.
[
'baseDir' => $baseDir, 'basePath' => '/w',
'/w/test.jpg',
'/w/test.jpg?edcf2'
],
// File that matches basePath, but not found on disk. Empty query.
[
'baseDir' => $baseDir, 'basePath' => '/w',
'/w/unknown.png',
'/w/unknown.png'
],
// File not matching basePath. Ignored.
[
'baseDir' => $baseDir, 'basePath' => '/w',
'/files/test.jpg'
],
// Empty string. Ignored.
[
'baseDir' => $baseDir, 'basePath' => '/w',
'',
''
],
// Similar path, but with domain component. Ignored.
[
'baseDir' => $baseDir, 'basePath' => '/w',
'//example.org/w/test.jpg'
],
[
'baseDir' => $baseDir, 'basePath' => '/w',
'https://www.example.org/w/test.jpg'
],
// Unrelated path with domain component. Ignored.
[
'baseDir' => $baseDir, 'basePath' => '/w',
'https://www.example.org/files/test.jpg'
],
[
'baseDir' => $baseDir, 'basePath' => '/w',
'//example.org/files/test.jpg'
],
// Unrelated path with domain, and empty base path (root mw install). Ignored.
[
'baseDir' => $baseDir, 'basePath' => '',
'https://www.example.org/files/test.jpg'
],
[
'baseDir' => $baseDir, 'basePath' => '',
// T155310
'//example.org/files/test.jpg'
],
// Check UploadPath before ResourceBasePath (T155146)
[
'baseDir' => dirname( $baseDir ), 'basePath' => '',
'uploadDir' => $baseDir, 'uploadPath' => '/images',
'/images/test.jpg',
'/images/test.jpg?edcf2'
],
];
}
/**
* Tests a particular case of transformCssMedia, using the given input, globals,
* expected return, and message
*
* Asserts that $expectedReturn is returned.
*
* options['queryData'] - value of query string
* options['media'] - passed into the method under the same name
* options['expectedReturn'] - expected return value
* options['message'] - PHPUnit message for assertion
*
* @param array $args Key-value array of arguments as shown above
*/
protected function assertTransformCssMediaCase( $args ) {
$queryData = $args['queryData'] ?? [];
$fauxRequest = new FauxRequest( $queryData, false );
$this->setRequest( $fauxRequest );
$actualReturn = OutputPage::transformCssMedia( $args['media'] );
$this->assertSame( $args['expectedReturn'], $actualReturn, $args['message'] );
}
public function testPrintRequests() {
$this->assertTransformCssMediaCase( [
'queryData' => [ 'printable' => '1' ],
'media' => 'screen',
'expectedReturn' => null,
'message' => 'On printable request, screen returns null'
] );
$this->assertTransformCssMediaCase( [
'queryData' => [ 'printable' => '1' ],
'media' => self::SCREEN_MEDIA_QUERY,
'expectedReturn' => null,
'message' => 'On printable request, screen media query returns null'
] );
$this->assertTransformCssMediaCase( [
'queryData' => [ 'printable' => '1' ],
'media' => self::SCREEN_ONLY_MEDIA_QUERY,
'expectedReturn' => null,
'message' => 'On printable request, screen media query with only returns null'
] );
$this->assertTransformCssMediaCase( [
'queryData' => [ 'printable' => '1' ],
'media' => 'print',
'expectedReturn' => '',
'message' => 'On printable request, media print returns empty string'
] );
}
/**
* Test screen requests, without either query parameter set
*/
public function testScreenRequests() {
$this->assertTransformCssMediaCase( [
'media' => 'screen',
'expectedReturn' => 'screen',
'message' => 'On screen request, screen media type is preserved'
] );
$this->assertTransformCssMediaCase( [
'media' => 'handheld',
'expectedReturn' => 'handheld',
'message' => 'On screen request, handheld media type is preserved'
] );
$this->assertTransformCssMediaCase( [
'media' => self::SCREEN_MEDIA_QUERY,
'expectedReturn' => self::SCREEN_MEDIA_QUERY,
'message' => 'On screen request, screen media query is preserved.'
] );
$this->assertTransformCssMediaCase( [
'media' => self::SCREEN_ONLY_MEDIA_QUERY,
'expectedReturn' => self::SCREEN_ONLY_MEDIA_QUERY,
'message' => 'On screen request, screen media query with only is preserved.'
] );
$this->assertTransformCssMediaCase( [
'media' => 'print',
'expectedReturn' => 'print',
'message' => 'On screen request, print media type is preserved'
] );
}
public function testIsTOCEnabled() {
$op = $this->newInstance();
$this->assertFalse( $op->isTOCEnabled() );
$this->assertFalse( $op->getOutputFlag( ParserOutputFlags::SHOW_TOC ) );
$pOut1 = $this->createParserOutputStub();
$op->addParserOutputMetadata( $pOut1 );
$this->assertFalse( $op->isTOCEnabled() );
$this->assertFalse( $op->getOutputFlag( ParserOutputFlags::SHOW_TOC ) );
$pOut2 = $this->createParserOutputStubWithFlags(
[], [ ParserOutputFlags::SHOW_TOC ]
);
$op->addParserOutput( $pOut2 );
$this->assertTrue( $op->isTOCEnabled() );
$this->assertTrue( $op->getOutputFlag( ParserOutputFlags::SHOW_TOC ) );
// The parser output doesn't disable the TOC after it was enabled
$op->addParserOutputMetadata( $pOut1 );
$this->assertTrue( $op->isTOCEnabled() );
$this->assertTrue( $op->getOutputFlag( ParserOutputFlags::SHOW_TOC ) );
}
public function testNoTOC() {
$op = $this->newInstance();
$this->assertFalse( $op->getOutputFlag( ParserOutputFlags::NO_TOC ) );
$stubPO1 = $this->createParserOutputStubWithFlags(
[], [ ParserOutputFlags::NO_TOC ]
);
$op->addParserOutputMetadata( $stubPO1 );
$this->assertTrue( $op->getOutputFlag( ParserOutputFlags::NO_TOC ) );
$stubPO2 = $this->createParserOutputStub();
$this->assertFalse( $stubPO2->getOutputFlag( ParserOutputFlags::NO_TOC ) );
$op->addParserOutput( $stubPO2 );
// Note that flags are OR'ed together, and not reset.
$this->assertTrue( $op->getOutputFlag( ParserOutputFlags::NO_TOC ) );
}
/**
* @dataProvider providePreloadLinkHeaders
* @covers \MediaWiki\ResourceLoader\SkinModule
*/
public function testPreloadLinkHeaders( $config, $result ) {
$ctx = $this->createMock( RL\Context::class );
$module = new RL\SkinModule();
$module->setConfig( new HashConfig( $config + ResourceLoaderTestCase::getSettings() ) );
$this->assertEquals( [ $result ], $module->getHeaders( $ctx ) );
}
public static function providePreloadLinkHeaders() {
return [
[
[
MainConfigNames::ResourceBasePath => '/w',
MainConfigNames::Logo => '/img/default.png',
MainConfigNames::Logos => [
'1.5x' => '/img/one-point-five.png',
'2x' => '/img/two-x.png',
],
],
'Link: </img/default.png>;rel=preload;as=image;media=' .
'not all and (min-resolution: 1.5dppx),' .
'</img/one-point-five.png>;rel=preload;as=image;media=' .
'(min-resolution: 1.5dppx) and (max-resolution: 1.999999dppx),' .
'</img/two-x.png>;rel=preload;as=image;media=(min-resolution: 2dppx)'
],
[
[
MainConfigNames::ResourceBasePath => '/w',
MainConfigNames::Logos => [
'1x' => '/img/default.png',
],
],
'Link: </img/default.png>;rel=preload;as=image'
],
[
[
MainConfigNames::ResourceBasePath => '/w',
MainConfigNames::Logos => [
'1x' => '/img/default.png',
'2x' => '/img/two-x.png',
],
],
'Link: </img/default.png>;rel=preload;as=image;media=' .
'not all and (min-resolution: 2dppx),' .
'</img/two-x.png>;rel=preload;as=image;media=(min-resolution: 2dppx)'
],
[
[
MainConfigNames::ResourceBasePath => '/w',
MainConfigNames::Logos => [
'1x' => '/img/default.png',
'svg' => '/img/vector.svg',
],
],
'Link: </img/vector.svg>;rel=preload;as=image'
],
[
[
MainConfigNames::ResourceBasePath => '/w',
MainConfigNames::Logos => [
'1x' => '/w/test.jpg',
],
MainConfigNames::UploadPath => '/w/images',
MainConfigNames::BaseDirectory => dirname( __DIR__ ) . '/../data/media'
],
'Link: </w/test.jpg?edcf2>;rel=preload;as=image',
],
];
}
/**
* @param int $titleLastRevision Last Title revision to set
* @param int $outputRevision Revision stored in OutputPage
* @param bool $expectedResult Expected result of $output->isRevisionCurrent call
* @dataProvider provideIsRevisionCurrent
*/
public function testIsRevisionCurrent( $titleLastRevision, $outputRevision, $expectedResult ) {
$titleMock = $this->createMock( Title::class );
$titleMock->method( 'getLatestRevID' )
->willReturn( $titleLastRevision );
$output = $this->newInstance( [], null );
$output->setTitle( $titleMock );
$output->setRevisionId( $outputRevision );
$this->assertEquals( $expectedResult, $output->isRevisionCurrent() );
}
public static function provideIsRevisionCurrent() {
return [
[ 10, null, true ],
[ 42, 42, true ],
[ null, 0, true ],
[ 42, 47, false ],
[ 47, 42, false ]
];
}
/**
* @dataProvider provideSendCacheControl
*/
public function testSendCacheControl( array $options = [], array $expectations = [] ) {
$this->overrideConfigValue( MainConfigNames::UsePigLatinVariant, $options['variant'] ?? false );
$output = $this->newInstance( [
MainConfigNames::UseCdn => $options['useCdn'] ?? false,
] );
$output->considerCacheSettingsFinal();
$cacheable = $options['enableClientCache'] ?? true;
if ( !$cacheable ) {
$output->disableClientCache();
}
$this->assertEquals( $cacheable, $output->couldBePublicCached() );
$output->setCdnMaxage( $options['cdnMaxAge'] ?? 0 );
if ( isset( $options['lastModified'] ) ) {
$output->setLastModified( $options['lastModified'] );
}
$response = $output->getRequest()->response();
if ( isset( $options['cookie'] ) ) {
$response->setCookie( 'test', 1234 );
}
$output->sendCacheControl();
$headers = [
'Vary' => 'Accept-Encoding, Cookie',
'Cache-Control' => 'private, must-revalidate, max-age=0',
'Expires' => true,
'Last-Modified' => false,
];
foreach ( $headers as $header => $default ) {
$value = $expectations[$header] ?? $default;
if ( $value === true ) {
$this->assertNotEmpty( $response->getHeader( $header ), "$header header" );
} elseif ( $value === false ) {
$this->assertNull( $response->getHeader( $header ), "$header header" );
} else {
$this->assertEquals( $value, $response->getHeader( $header ), "$header header" );
}
}
}
public static function provideSendCacheControl() {
return [
'Vary on variant' => [
[
'variant' => true,
],
[
'Vary' => 'Accept-Encoding, Cookie, Accept-Language',
]
],
'Private by default' => [
[],
[
'Cache-Control' => 'private, must-revalidate, max-age=0',
],
],
'Cookies force private' => [
[
'cookie' => true,
'useCdn' => true,
'cdnMaxAge' => 300,
],
[
'Cache-Control' => 'private, must-revalidate, max-age=0',
]
],
'Disable client cache' => [
[
'enableClientCache' => false,
'useCdn' => true,
'cdnMaxAge' => 300,
],
[
'Cache-Control' => 'no-cache, no-store, max-age=0, must-revalidate',
],
],
'Set last modified' => [
[
// 0 is the current time, so we'll use 1 instead.
'lastModified' => 1,
],
[
'Last-Modified' => 'Thu, 01 Jan 1970 00:00:01 GMT',
]
],
'Public' => [
[
'useCdn' => true,
'cdnMaxAge' => 300,
],
[
'Cache-Control' => 's-maxage=300, must-revalidate, max-age=0',
'Expires' => false,
],
],
];
}
public function provideGetJsVarsEditable() {
yield 'can edit and create' => [
'performer' => $this->mockAnonAuthorityWithPermissions( [ 'edit', 'create' ] ),
'expectedEditableConfig' => [
'wgIsProbablyEditable' => true,
'wgRelevantPageIsProbablyEditable' => true,
]
];
yield 'cannot edit or create' => [
'performer' => $this->mockAnonAuthorityWithoutPermissions( [ 'edit', 'create' ] ),
'expectedEditableConfig' => [
'wgIsProbablyEditable' => false,
'wgRelevantPageIsProbablyEditable' => false,
]
];
yield 'only can edit relevant title' => [
'performer' => $this->mockAnonAuthority( static function (
string $permission,
PageIdentity $page
) {
return ( $permission === 'edit' || $permission === 'create' ) && $page->getDBkey() === 'RelevantTitle';
} ),
'expectedEditableConfig' => [
'wgIsProbablyEditable' => false,
'wgRelevantPageIsProbablyEditable' => true,
]
];
}
/**
* @dataProvider provideGetJsVarsEditable
*/
public function testGetJsVarsEditable( Authority $performer, array $expectedEditableConfig ) {
$op = $this->newInstance( [], null, null, $performer );
$op->getContext()->getSkin()->setRelevantTitle( Title::makeTitle( NS_MAIN, 'RelevantTitle' ) );
$this->assertArraySubmapSame( $expectedEditableConfig, $op->getJSVars() );
}
public function provideJsVarsAboutPageLang() {
// Format:
// - expected
// - title
// - site content language
// - user language
// - wgDefaultLanguageVariant
return [
[ 'fr', [ NS_HELP, 'I_need_somebody' ], 'fr', 'fr', false ],
[ 'es', [ NS_HELP, 'I_need_somebody' ], 'es', 'zh-tw', false ],
[ 'zh', [ NS_HELP, 'I_need_somebody' ], 'zh', 'zh-tw', false ],
[ 'es', [ NS_HELP, 'I_need_somebody' ], 'es', 'zh-tw', 'zh-cn' ],
[ 'es', [ NS_MEDIAWIKI, 'About' ], 'es', 'zh-tw', 'zh-cn' ],
[ 'es', [ NS_MEDIAWIKI, 'About/' ], 'es', 'zh-tw', 'zh-cn' ],
[ 'de', [ NS_MEDIAWIKI, 'About/de' ], 'es', 'zh-tw', 'zh-cn' ],
[ 'en', [ NS_MEDIAWIKI, 'Common.js' ], 'es', 'zh-tw', 'zh-cn' ],
[ 'en', [ NS_MEDIAWIKI, 'Common.css' ], 'es', 'zh-tw', 'zh-cn' ],
[ 'en', [ NS_USER, 'JohnDoe/Common.js' ], 'es', 'zh-tw', 'zh-cn' ],
[ 'en', [ NS_USER, 'JohnDoe/Monobook.css' ], 'es', 'zh-tw', 'zh-cn' ],
[ 'zh-cn', [ NS_HELP, 'I_need_somebody' ], 'zh', 'zh-tw', 'zh-cn' ],
[ 'zh', [ NS_MEDIAWIKI, 'About' ], 'zh', 'zh-tw', 'zh-cn' ],
[ 'zh', [ NS_MEDIAWIKI, 'About/' ], 'zh', 'zh-tw', 'zh-cn' ],
[ 'de', [ NS_MEDIAWIKI, 'About/de' ], 'zh', 'zh-tw', 'zh-cn' ],
[ 'zh-cn', [ NS_MEDIAWIKI, 'About/zh-cn' ], 'zh', 'zh-tw', 'zh-cn' ],
[ 'zh-tw', [ NS_MEDIAWIKI, 'About/zh-tw' ], 'zh', 'zh-tw', 'zh-cn' ],
[ 'en', [ NS_MEDIAWIKI, 'Common.js' ], 'zh', 'zh-tw', 'zh-cn' ],
[ 'en', [ NS_MEDIAWIKI, 'Common.css' ], 'zh', 'zh-tw', 'zh-cn' ],
[ 'en', [ NS_USER, 'JohnDoe/Common.js' ], 'zh', 'zh-tw', 'zh-cn' ],
[ 'en', [ NS_USER, 'JohnDoe/Monobook.css' ], 'zh', 'zh-tw', 'zh-cn' ],
[ 'nl', [ NS_SPECIAL, 'BlankPage' ], 'en', 'nl', false ],
[ 'zh-tw', [ NS_SPECIAL, 'NewPages' ], 'es', 'zh-tw', 'zh-cn' ],
[ 'zh-tw', [ NS_SPECIAL, 'NewPages' ], 'zh', 'zh-tw', 'zh-cn' ],
[ 'sr-ec', [ NS_FILE, 'Example' ], 'sr', 'sr', 'sr-ec' ],
[ 'sr', [ NS_FILE, 'Example' ], 'sr', 'sr', 'sr' ],
[ 'sr-ec', [ NS_MEDIAWIKI, 'Example' ], 'sr-ec', 'sr-ec', 'sr' ],
[ 'sr', [ NS_MEDIAWIKI, 'Example' ], 'sr', 'sr', 'sr-ec' ],
];
}
/**
* @dataProvider provideJsVarsAboutPageLang
*/
public function testGetJsVarsAboutPageLang( $expected, $title, $contLang, $userLang, $variant ) {
$this->overrideConfigValues( [
MainConfigNames::DefaultLanguageVariant => $variant,
] );
$this->setContentLang( $contLang );
$output = $this->newInstance(
[ MainConfigNames::LanguageCode => $contLang ],
new FauxRequest( [ 'uselang' => $userLang ] ),
'notitle'
);
$output->setTitle( Title::makeTitle( $title[0], $title[1] ) );
$this->assertArraySubmapSame( [
'wgPageViewLanguage' => $expected,
'wgPageContentLanguage' => $expected,
], $output->getJSVars() );
}
/**
* @param bool $registered
* @param bool $matchToken
* @return MockObject|User
*/
private function mockUser( bool $registered, bool $matchToken ) {
$user = $this->createNoOpMock( User::class, [ 'isRegistered', 'matchEditToken' ] );
$user->method( 'isRegistered' )->willReturn( $registered );
$user->method( 'matchEditToken' )->willReturn( $matchToken );
return $user;
}
public function provideUserCanPreview() {
yield 'all good' => [
'performer' => $this->mockUserAuthorityWithPermissions(
$this->mockUser( true, true ),
[ 'edit' ]
),
'request' => new FauxRequest( [ 'action' => 'submit' ], true ),
true
];
yield 'get request' => [
'performer' => $this->mockUserAuthorityWithPermissions(
$this->mockUser( true, true ),
[ 'edit' ]
),
'request' => new FauxRequest( [ 'action' => 'submit' ], false ),
false
];
yield 'not a submit action' => [
'performer' => $this->mockUserAuthorityWithPermissions(
$this->mockUser( true, true ),
[ 'edit' ]
),
'request' => new FauxRequest( [ 'action' => 'something' ], true ),
false
];
yield 'anon can not' => [
'performer' => $this->mockUserAuthorityWithPermissions(
$this->mockUser( false, true ),
[ 'edit' ]
),
'request' => new FauxRequest( [ 'action' => 'submit' ], true ),
false
];
yield 'token not match' => [
'performer' => $this->mockUserAuthorityWithPermissions(
$this->mockUser( true, false ),
[ 'edit' ]
),
'request' => new FauxRequest( [ 'action' => 'submit' ], true ),
false
];
yield 'no permission' => [
'performer' => $this->mockUserAuthorityWithoutPermissions(
$this->mockUser( true, true ),
[ 'edit' ]
),
'request' => new FauxRequest( [ 'action' => 'submit' ], true ),
false
];
}
/**
* @dataProvider provideUserCanPreview
*/
public function testUserCanPreview( Authority $performer, WebRequest $request, bool $expected ) {
$op = $this->newInstance( [], $request, null, $performer );
$this->assertSame( $expected, $op->userCanPreview() );
}
public function providePermissionStatus() {
yield 'no errors' => [
PermissionStatus::newEmpty(),
'',
];
yield 'one message' => [
PermissionStatus::newEmpty()->fatal( 'badaccess-group0' ),
'(permissionserrorstext: 1)
<div class="permissions-errors"><div class="mw-permissionerror-badaccess-group0">(badaccess-group0)</div></div>',
];
yield 'two messages' => [
PermissionStatus::newEmpty()->fatal( 'badaccess-group0' )->fatal( 'foobar' ),
'(permissionserrorstext: 2)
<ul class="permissions-errors"><li class="mw-permissionerror-badaccess-group0">(badaccess-group0)</li><li class="mw-permissionerror-foobar">(foobar)</li></ul>',
];
}
public function provideFormatPermissionStatus() {
yield 'RawMessage' => [
PermissionStatus::newEmpty()->fatal( new RawMessage( 'Foo Bar' ) ),
'(permissionserrorstext: 1)
<div class="permissions-errors"><div class="mw-permissionerror-rawmessage">Foo Bar</div></div>',
];
}
public function provideFormatPermissionsErrorMessage() {
yield 'RawMessage' => [
PermissionStatus::newEmpty()->fatal( new RawMessage( 'Foo Bar' ) ),
'(permissionserrorstext: 1)
<div class="permissions-errors"><div class="mw-permissionerror-rawmessage">(rawmessage: Foo Bar)</div></div>',
];
}
/**
* @dataProvider providePermissionStatus
* @dataProvider provideFormatPermissionStatus
*/
public function testFormatPermissionStatus( PermissionStatus $status, string $expected ) {
$this->overrideConfigValue( MainConfigNames::LanguageCode, 'qqx' );
$actual = self::newInstance()->formatPermissionStatus( $status );
$this->assertEquals( $expected, $actual );
}
/**
* @dataProvider providePermissionStatus
* @dataProvider provideFormatPermissionsErrorMessage
*/
public function testFormatPermissionsErrorMessage( PermissionStatus $status, string $expected ) {
$this->overrideConfigValue( MainConfigNames::LanguageCode, 'qqx' );
$this->filterDeprecated( '/OutputPage::formatPermissionsErrorMessage was deprecated/' );
// Unlike formatPermissionStatus, this method doesn't accept good statuses
$actual = $status->isGood() ? '' :
self::newInstance()->formatPermissionsErrorMessage( $status->toLegacyErrorArray() );
$this->assertEquals( $expected, $actual );
}
private function newInstance(
array $config = [],
?WebRequest $request = null,
$option = null,
?Authority $performer = null
): OutputPage {
$this->overrideConfigValues( [
// Avoid configured skin affecting the headings
MainConfigNames::ParserEnableLegacyHeadingDOM => false,
MainConfigNames::DefaultSkin => 'fallback',
MainConfigNames::HiddenPrefs => [ 'skin' ],
] );
$context = new RequestContext();
$context->setConfig( new MultiConfig( [
new HashConfig( $config + [
MainConfigNames::AppleTouchIcon => false,
MainConfigNames::EnableCanonicalServerLink => false,
MainConfigNames::Favicon => false,
MainConfigNames::Feed => false,
MainConfigNames::LanguageCode => false,
MainConfigNames::ReferrerPolicy => false,
MainConfigNames::RightsPage => false,
MainConfigNames::RightsUrl => false,
MainConfigNames::UniversalEditButton => false,
] ),
$this->getServiceContainer()->getMainConfig(),
] ) );
if ( $option !== 'notitle' ) {
$context->setTitle( Title::makeTitle( NS_MAIN, 'My test page' ) );
}
if ( $request ) {
$context->setRequest( $request );
}
if ( $performer ) {
$context->setAuthority( $performer );
}
return new OutputPage( $context );
}
}
PK ! content/TextContentTest.phpnu Iw <?php
use MediaWiki\Content\Content;
use MediaWiki\Content\JavaScriptContent;
use MediaWiki\Content\TextContent;
use MediaWiki\Content\WikitextContent;
use MediaWiki\Context\RequestContext;
use MediaWiki\MainConfigNames;
use MediaWiki\Title\Title;
use MediaWiki\User\User;
/**
* Needs database to do link updates.
*
* @group ContentHandler
* @group Database
* @covers \MediaWiki\Content\TextContent
* @covers \MediaWiki\Content\TextContentHandler
*/
class TextContentTest extends MediaWikiLangTestCase {
/** @var RequestContext */
protected $context;
protected function setUp(): void {
parent::setUp();
// Anon user
$user = new User();
$user->setName( '127.0.0.1' );
$this->context = new RequestContext();
$this->context->setTitle( Title::makeTitle( NS_MAIN, 'Test' ) );
$this->context->setUser( $user );
RequestContext::getMain()->setTitle( $this->context->getTitle() );
$this->overrideConfigValues( [
MainConfigNames::TextModelsToParse => [
CONTENT_MODEL_WIKITEXT,
CONTENT_MODEL_CSS,
CONTENT_MODEL_JAVASCRIPT,
],
MainConfigNames::CapitalLinks => true,
] );
$this->clearHook( 'ContentGetParserOutput' );
}
/**
* NOTE: Overridden by subclass!
*
* @param string $text
* @return TextContent
*/
public function newContent( $text ) {
return new TextContent( $text );
}
public static function dataGetRedirectTarget() {
return [
[ '#REDIRECT [[Test]]',
null,
],
];
}
/**
* @dataProvider dataGetRedirectTarget
*/
public function testGetRedirectTarget( $text, $expected ) {
$content = $this->newContent( $text );
$t = $content->getRedirectTarget();
if ( $expected === null ) {
$this->assertNull( $t, "text should not have generated a redirect target: $text" );
} else {
$this->assertEquals( $expected, $t->getPrefixedText() );
}
}
/**
* @dataProvider dataGetRedirectTarget
*/
public function testIsRedirect( $text, $expected ) {
$content = $this->newContent( $text );
$this->assertEquals( $expected !== null, $content->isRedirect() );
}
public static function dataIsCountable() {
return [
[ '',
null,
'any',
true
],
[ 'Foo',
null,
'any',
true
],
];
}
/**
* @dataProvider dataIsCountable
*/
public function testIsCountable( $text, $hasLinks, $mode, $expected ) {
$this->overrideConfigValue( MainConfigNames::ArticleCountMethod, $mode );
$content = $this->newContent( $text );
$v = $content->isCountable( $hasLinks );
$this->assertEquals(
$expected,
$v,
'isCountable() returned unexpected value ' . var_export( $v, true )
. ' instead of ' . var_export( $expected, true )
. " in mode `$mode` for text \"$text\""
);
}
public static function dataGetTextForSummary() {
return [
[ "hello\nworld.",
16,
'hello world.',
],
[ 'hello world.',
8,
'hello...',
],
[ '[[hello world]].',
8,
'[[hel...',
],
];
}
/**
* @dataProvider dataGetTextForSummary
*/
public function testGetTextForSummary( $text, $maxlength, $expected ) {
$content = $this->newContent( $text );
$this->assertEquals( $expected, $content->getTextForSummary( $maxlength ) );
}
/**
*/
public function testCopy() {
$content = $this->newContent( 'hello world.' );
$copy = $content->copy();
$this->assertTrue( $content->equals( $copy ), 'copy must be equal to original' );
$this->assertEquals( 'hello world.', $copy->getText() );
}
public function testGetTextMethods() {
$content = $this->newContent( 'hello world.' );
$this->assertEquals( 12, $content->getSize() );
$this->assertEquals( 'hello world.', $content->getText() );
$this->assertEquals( 'hello world.', $content->getTextForSearchIndex() );
$this->assertEquals( 'hello world.', $content->getNativeData() );
$this->assertEquals( 'hello world.', $content->getWikitextForTransclusion() );
}
public function testGetModel() {
$content = $this->newContent( "hello world." );
$this->assertEquals( CONTENT_MODEL_TEXT, $content->getModel() );
}
public function testGetContentHandler() {
$content = $this->newContent( "hello world." );
$this->assertEquals( CONTENT_MODEL_TEXT, $content->getContentHandler()->getModelID() );
}
public static function dataIsEmpty() {
return [
[ '', true ],
[ ' ', false ],
[ '0', false ],
[ 'hallo welt.', false ],
];
}
/**
* @dataProvider dataIsEmpty
*/
public function testIsEmpty( $text, $empty ) {
$content = $this->newContent( $text );
$this->assertEquals( $empty, $content->isEmpty() );
}
public static function dataEquals() {
return [
[ new TextContent( "hallo" ), null, false ],
[ new TextContent( "hallo" ), new TextContent( "hallo" ), true ],
[ new TextContent( "hallo" ), new JavaScriptContent( "hallo" ), false ],
[ new TextContent( "hallo" ), new WikitextContent( "hallo" ), false ],
[ new TextContent( "hallo" ), new TextContent( "HALLO" ), false ],
];
}
/**
* @dataProvider dataEquals
*/
public function testEquals( Content $a, ?Content $b = null, $equal = false ) {
$this->assertEquals( $equal, $a->equals( $b ) );
}
public static function provideConvert() {
return [
[ // #0
'Hallo Welt',
CONTENT_MODEL_WIKITEXT,
'lossless',
'Hallo Welt'
],
[ // #1
'Hallo Welt',
CONTENT_MODEL_WIKITEXT,
'lossless',
'Hallo Welt'
],
[ // #1
'Hallo Welt',
CONTENT_MODEL_CSS,
'lossless',
'Hallo Welt'
],
[ // #1
'Hallo Welt',
CONTENT_MODEL_JAVASCRIPT,
'lossless',
'Hallo Welt'
],
];
}
/**
* @dataProvider provideConvert
*/
public function testConvert( $text, $model, $lossy, $expectedNative ) {
$content = $this->newContent( $text );
/** @var TextContent $converted */
$converted = $content->convert( $model, $lossy );
if ( $expectedNative === false ) {
$this->assertFalse( $converted, "conversion to $model was expected to fail!" );
} else {
$this->assertInstanceOf( Content::class, $converted );
$this->assertEquals( $expectedNative, $converted->getText() );
}
}
/**
* @dataProvider provideNormalizeLineEndings
*/
public function testNormalizeLineEndings( $input, $expected ) {
$this->assertEquals( $expected, TextContent::normalizeLineEndings( $input ) );
}
public static function provideNormalizeLineEndings() {
return [
[
"Foo\r\nbar",
"Foo\nbar"
],
[
"Foo\rbar",
"Foo\nbar"
],
[
"Foobar\n ",
"Foobar"
]
];
}
public function testSerialize() {
$cnt = $this->newContent( 'testing text' );
$this->assertSame( 'testing text', $cnt->serialize() );
}
}
PK ! MS S content/ContentHandlerTest.phpnu Iw <?php
use MediaWiki\Content\ContentHandler;
use MediaWiki\Content\CssContentHandler;
use MediaWiki\Content\JavaScriptContentHandler;
use MediaWiki\Content\JsonContent;
use MediaWiki\Content\JsonContentHandler;
use MediaWiki\Content\TextContentHandler;
use MediaWiki\Content\ValidationParams;
use MediaWiki\Content\WikitextContent;
use MediaWiki\Content\WikitextContentHandler;
use MediaWiki\Context\RequestContext;
use MediaWiki\Language\Language;
use MediaWiki\Languages\LanguageNameUtils;
use MediaWiki\Linker\LinkRenderer;
use MediaWiki\MainConfigNames;
use MediaWiki\Page\Hook\OpportunisticLinksUpdateHook;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Page\PageIdentityValue;
use MediaWiki\Parser\MagicWordFactory;
use MediaWiki\Parser\ParserFactory;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Parser\Parsoid\ParsoidParserFactory;
use MediaWiki\Title\Title;
use MediaWiki\Title\TitleFactory;
use Wikimedia\TestingAccessWrapper;
use Wikimedia\UUID\GlobalIdGenerator;
/**
* @group ContentHandler
* @group Database
* @covers \MediaWiki\Content\ContentHandler
*/
class ContentHandlerTest extends MediaWikiIntegrationTestCase {
protected function setUp(): void {
parent::setUp();
$this->overrideConfigValues( [
MainConfigNames::ExtraNamespaces => [
12312 => 'Dummy',
12313 => 'Dummy_talk',
],
// The below tests assume that namespaces not mentioned here (Help, User, MediaWiki, ..)
// default to CONTENT_MODEL_WIKITEXT.
MainConfigNames::NamespaceContentModels => [
12312 => 'testing',
],
MainConfigNames::ContentHandlers => [
CONTENT_MODEL_WIKITEXT => [
'class' => WikitextContentHandler::class,
'services' => [
'TitleFactory',
'ParserFactory',
'GlobalIdGenerator',
'LanguageNameUtils',
'LinkRenderer',
'MagicWordFactory',
'ParsoidParserFactory',
],
],
CONTENT_MODEL_JAVASCRIPT => JavaScriptContentHandler::class,
CONTENT_MODEL_JSON => JsonContentHandler::class,
CONTENT_MODEL_CSS => CssContentHandler::class,
CONTENT_MODEL_TEXT => TextContentHandler::class,
'testing' => DummyContentHandlerForTesting::class,
'testing-callbacks' => static function ( $modelId ) {
return new DummyContentHandlerForTesting( $modelId );
}
],
] );
}
public function addDBDataOnce() {
$this->insertPage( 'Not_Main_Page', 'This is not a main page' );
$this->insertPage( 'Smithee', 'A smithee is one who smiths. See also [[Alan Smithee]]' );
}
public static function dataGetDefaultModelFor() {
return [
[ 'Help:Foo', CONTENT_MODEL_WIKITEXT ],
[ 'Help:Foo.js', CONTENT_MODEL_WIKITEXT ],
[ 'Help:Foo.css', CONTENT_MODEL_WIKITEXT ],
[ 'Help:Foo.json', CONTENT_MODEL_WIKITEXT ],
[ 'Help:Foo/bar.js', CONTENT_MODEL_WIKITEXT ],
[ 'User:Foo', CONTENT_MODEL_WIKITEXT ],
[ 'User:Foo.js', CONTENT_MODEL_WIKITEXT ],
[ 'User:Foo.css', CONTENT_MODEL_WIKITEXT ],
[ 'User:Foo.json', CONTENT_MODEL_WIKITEXT ],
[ 'User:Foo/bar.js', CONTENT_MODEL_JAVASCRIPT ],
[ 'User:Foo/bar.css', CONTENT_MODEL_CSS ],
[ 'User:Foo/bar.json', CONTENT_MODEL_JSON ],
[ 'User:Foo/bar.json.nope', CONTENT_MODEL_WIKITEXT ],
[ '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.JS', CONTENT_MODEL_WIKITEXT ],
[ 'MediaWiki:Foo.css', CONTENT_MODEL_CSS ],
[ 'MediaWiki:Foo.css.xxx', CONTENT_MODEL_WIKITEXT ],
[ 'MediaWiki:Foo.CSS', CONTENT_MODEL_WIKITEXT ],
[ 'MediaWiki:Foo.json', CONTENT_MODEL_JSON ],
[ 'MediaWiki:Foo.JSON', CONTENT_MODEL_WIKITEXT ],
];
}
/**
* @dataProvider dataGetDefaultModelFor
*/
public function testGetDefaultModelFor( $title, $expectedModelId ) {
$title = Title::newFromText( $title );
$this->hideDeprecated( 'MediaWiki\\Content\\ContentHandler::getDefaultModelFor' );
$this->assertEquals( $expectedModelId, ContentHandler::getDefaultModelFor( $title ) );
}
public static function dataGetLocalizedName() {
return [
[ null, null ],
[ "xyzzy", null ],
// XXX: depends on content language
[ CONTENT_MODEL_JAVASCRIPT, '/javascript/i' ],
];
}
/**
* @dataProvider dataGetLocalizedName
*/
public function testGetLocalizedName( $id, $expected ) {
$name = ContentHandler::getLocalizedName( $id );
if ( $expected ) {
$this->assertNotNull( $name, "no name found for content model $id" );
$this->assertTrue( preg_match( $expected, $name ) > 0,
"content model name for #$id did not match pattern $expected"
);
} else {
$this->assertEquals( $id, $name, "localization of unknown model $id should have "
. "fallen back to use the model id directly."
);
}
}
public static function dataGetPageLanguage() {
global $wgLanguageCode;
return [
[ "Main", $wgLanguageCode ],
[ "Dummy:Foo", $wgLanguageCode ],
[ "MediaWiki:common.js", 'en' ],
[ "User:Foo/common.js", 'en' ],
[ "MediaWiki:common.css", 'en' ],
[ "User:Foo/common.css", 'en' ],
[ "User:Foo", $wgLanguageCode ],
];
}
/**
* @dataProvider dataGetPageLanguage
*/
public function testGetPageLanguage( $title, $expected ) {
$title = Title::newFromText( $title );
$this->getServiceContainer()->getLinkCache()->addBadLinkObj( $title );
$handler = $this->getServiceContainer()
->getContentHandlerFactory()
->getContentHandler( $title->getContentModel() );
$lang = $handler->getPageLanguage( $title );
$this->assertInstanceOf( Language::class, $lang );
$this->assertEquals( $expected, $lang->getCode() );
}
public function testGetContentText_Null() {
$this->hideDeprecated( 'MediaWiki\\Content\\ContentHandler::getContentText' );
$content = null;
$text = ContentHandler::getContentText( $content );
$this->assertSame( '', $text );
}
public function testGetContentText_TextContent() {
$this->hideDeprecated( 'MediaWiki\\Content\\ContentHandler::getContentText' );
$content = new WikitextContent( "hello world" );
$text = ContentHandler::getContentText( $content );
$this->assertEquals( $content->getText(), $text );
}
public function testGetContentText_NonTextContent() {
$this->hideDeprecated( 'MediaWiki\\Content\\ContentHandler::getContentText' );
$content = new DummyContentForTesting( "hello world" );
$text = ContentHandler::getContentText( $content );
$this->assertNull( $text );
}
public static function dataMakeContent() {
return [
[ 'hallo', 'Help:Test', null, null, CONTENT_MODEL_WIKITEXT, false ],
[ 'hallo', 'MediaWiki:Test.js', null, null, CONTENT_MODEL_JAVASCRIPT, false ],
[ 'hallo', 'Dummy:Test', null, null, "testing", false ],
[
'hallo',
'Help:Test',
null,
CONTENT_FORMAT_WIKITEXT,
CONTENT_MODEL_WIKITEXT,
false
],
[
'hallo',
'MediaWiki:Test.js',
null,
CONTENT_FORMAT_JAVASCRIPT,
CONTENT_MODEL_JAVASCRIPT,
false
],
[ 'hallo', 'Dummy:Test', null, "testing", "testing", false ],
[ 'hallo', 'Help:Test', CONTENT_MODEL_CSS, null, CONTENT_MODEL_CSS, false ],
[
'hallo',
'MediaWiki:Test.js',
CONTENT_MODEL_CSS,
null,
CONTENT_MODEL_CSS,
false
],
[
serialize( 'hallo' ),
'Dummy:Test',
CONTENT_MODEL_CSS,
null,
CONTENT_MODEL_CSS,
false
],
[ 'hallo', 'Help:Test', CONTENT_MODEL_WIKITEXT, "testing", null, true ],
[ 'hallo', 'MediaWiki:Test.js', CONTENT_MODEL_CSS, "testing", null, true ],
[ 'hallo', 'Dummy:Test', CONTENT_MODEL_JAVASCRIPT, "testing", null, true ],
];
}
/**
* @dataProvider dataMakeContent
*/
public function testMakeContent( $data, $title, $modelId, $format,
$expectedModelId, $shouldFail
) {
$title = Title::newFromText( $title );
$this->getServiceContainer()->getLinkCache()->addBadLinkObj( $title );
try {
$content = ContentHandler::makeContent( $data, $title, $modelId, $format );
if ( $shouldFail ) {
$this->fail( "ContentHandler::makeContent should have failed!" );
}
$this->assertEquals( $expectedModelId, $content->getModel(), 'bad model id' );
$this->assertEquals( $data, $content->serialize(), 'bad serialized data' );
} catch ( MWException $ex ) {
if ( !$shouldFail ) {
$this->fail( "ContentHandler::makeContent failed unexpectedly: " . $ex->getMessage() );
} else {
// dummy, so we don't get the "test did not perform any assertions" message.
$this->assertTrue( true );
}
}
}
/**
* getAutoSummary() should set "Created blank page" summary if we save an empy string.
*/
public function testGetAutosummary() {
$this->setContentLang( 'en' );
$content = new DummyContentHandlerForTesting( CONTENT_MODEL_WIKITEXT );
$title = Title::makeTitle( NS_HELP, 'Test' );
// Create a new content object with no content
$newContent = ContentHandler::makeContent( '', $title, CONTENT_MODEL_WIKITEXT, null );
// first check, if we become a blank page created summary with the right bitmask
$autoSummary = $content->getAutosummary( null, $newContent, 97 );
$this->assertEquals(
wfMessage( 'autosumm-newblank' )->inContentLanguage()->text(),
$autoSummary
);
// now check, what we become with another bitmask
$autoSummary = $content->getAutosummary( null, $newContent, 92 );
$this->assertSame( '', $autoSummary );
}
/**
* Test software tag that is added when content model of the page changes
*/
public function testGetChangeTag() {
$this->overrideConfigValue( MainConfigNames::SoftwareTags, [ 'mw-contentmodelchange' => true ] );
$wikitextContentHandler = new DummyContentHandlerForTesting( CONTENT_MODEL_WIKITEXT );
// Create old content object with javascript content model
$oldContent = ContentHandler::makeContent( '', null, CONTENT_MODEL_JAVASCRIPT, null );
// Create new content object with wikitext content model
$newContent = ContentHandler::makeContent( '', null, CONTENT_MODEL_WIKITEXT, null );
// Get the tag for this edit
$tag = $wikitextContentHandler->getChangeTag( $oldContent, $newContent, EDIT_UPDATE );
$this->assertSame( 'mw-contentmodelchange', $tag );
}
public function testSupportsCategories() {
$handler = new DummyContentHandlerForTesting( CONTENT_MODEL_WIKITEXT );
$this->assertTrue( $handler->supportsCategories(), 'content model supports categories' );
}
public function testSupportsDirectEditing() {
$handler = new DummyContentHandlerForTesting( CONTENT_MODEL_JSON );
$this->assertFalse( $handler->supportsDirectEditing(), 'direct editing is not supported' );
}
public static function dummyHookHandler( $foo, &$text, $bar ) {
if ( $text === null || $text === false ) {
return false;
}
$text = strtoupper( $text );
return true;
}
public static function provideGetModelForID() {
return [
[ CONTENT_MODEL_WIKITEXT, WikitextContentHandler::class ],
[ CONTENT_MODEL_JAVASCRIPT, JavaScriptContentHandler::class ],
[ CONTENT_MODEL_JSON, JsonContentHandler::class ],
[ CONTENT_MODEL_CSS, CssContentHandler::class ],
[ CONTENT_MODEL_TEXT, TextContentHandler::class ],
[ 'testing', DummyContentHandlerForTesting::class ],
[ 'testing-callbacks', DummyContentHandlerForTesting::class ],
];
}
/**
* @dataProvider provideGetModelForID
*/
public function testGetModelForID( $modelId, $handlerClass ) {
$handler = $this->getServiceContainer()->getContentHandlerFactory()
->getContentHandler( $modelId );
$this->assertInstanceOf( $handlerClass, $handler );
}
public function testGetFieldsForSearchIndex() {
$searchEngine = $this->newSearchEngine();
$handler = $this->getMockBuilder( ContentHandler::class )
->onlyMethods(
[ 'serializeContent', 'unserializeContent', 'makeEmptyContent' ]
)
->disableOriginalConstructor()
->getMock();
$fields = $handler->getFieldsForSearchIndex( $searchEngine );
$this->assertArrayHasKey( 'category', $fields );
$this->assertArrayHasKey( 'external_link', $fields );
$this->assertArrayHasKey( 'outgoing_link', $fields );
$this->assertArrayHasKey( 'template', $fields );
$this->assertArrayHasKey( 'content_model', $fields );
}
private function newSearchEngine() {
$searchEngine = $this->createMock( SearchEngine::class );
$searchEngine->method( 'makeSearchFieldMapping' )
->willReturnCallback( static function ( $name, $type ) {
return new DummySearchIndexFieldDefinition( $name, $type );
} );
return $searchEngine;
}
public function testDataIndexFields() {
$mockEngine = $this->createMock( SearchEngine::class );
$title = Title::makeTitle( NS_MAIN, 'Not_Main_Page' );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$this->setTemporaryHook( 'SearchDataForIndex',
static function (
&$fields,
ContentHandler $handler,
WikiPage $page,
ParserOutput $output,
SearchEngine $engine
) {
$fields['testDataField'] = 'test content';
} );
$revision = $page->getRevisionRecord();
$output = $page->getContentHandler()->getParserOutputForIndexing( $page, null, $revision );
$data = $page->getContentHandler()->getDataForSearchIndex( $page, $output, $mockEngine, $revision );
$this->assertArrayHasKey( 'text', $data );
$this->assertArrayHasKey( 'text_bytes', $data );
$this->assertArrayHasKey( 'language', $data );
$this->assertArrayHasKey( 'testDataField', $data );
$this->assertEquals( 'test content', $data['testDataField'] );
$this->assertEquals( 'wikitext', $data['content_model'] );
}
public function testParserOutputForIndexing() {
$opportunisticUpdateHook =
$this->createMock( OpportunisticLinksUpdateHook::class );
// WikiPage::triggerOpportunisticLinksUpdate should not be triggered when
// getParserOutputForIndexing is called
$opportunisticUpdateHook->expects( $this->never() )
->method( 'onOpportunisticLinksUpdate' )
->willReturn( false );
$this->setTemporaryHook( 'OpportunisticLinksUpdate', $opportunisticUpdateHook );
$title = Title::makeTitle( NS_MAIN, 'Smithee' );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$revision = $page->getRevisionRecord();
$out = $page->getContentHandler()->getParserOutputForIndexing( $page, null, $revision );
$this->assertInstanceOf( ParserOutput::class, $out );
$this->assertStringContainsString( 'one who smiths', $out->getRawText() );
}
public function testGetContentModelsHook() {
$this->setTemporaryHook( 'GetContentModels', static function ( &$models ) {
$models[] = 'Ferrari';
} );
$this->hideDeprecated( 'MediaWiki\\Content\\ContentHandler::getContentModels' );
$this->assertContains( 'Ferrari', ContentHandler::getContentModels() );
}
public function testGetSlotDiffRenderer_default() {
$this->mergeMwGlobalArrayValue( 'wgHooks', [
'GetSlotDiffRenderer' => [],
] );
// test default renderer
$contentHandler = new WikitextContentHandler(
CONTENT_MODEL_WIKITEXT,
$this->createMock( TitleFactory::class ),
$this->createMock( ParserFactory::class ),
$this->createMock( GlobalIdGenerator::class ),
$this->createMock( LanguageNameUtils::class ),
$this->createMock( LinkRenderer::class ),
$this->createMock( MagicWordFactory::class ),
$this->createMock( ParsoidParserFactory::class )
);
$slotDiffRenderer = $contentHandler->getSlotDiffRenderer( RequestContext::getMain() );
$this->assertInstanceOf( TextSlotDiffRenderer::class, $slotDiffRenderer );
}
public function testGetSlotDiffRenderer_bc() {
$this->mergeMwGlobalArrayValue( 'wgHooks', [
'GetSlotDiffRenderer' => [],
] );
// test B/C renderer
$customDifferenceEngine = $this->createMock( DifferenceEngine::class );
// hack to track object identity across cloning
$customDifferenceEngine->objectId = 12345;
$customContentHandler = $this->getMockBuilder( ContentHandler::class )
->setConstructorArgs( [ 'foo', [] ] )
->onlyMethods( [ 'createDifferenceEngine' ] )
->getMockForAbstractClass();
$customContentHandler->method( 'createDifferenceEngine' )
->willReturn( $customDifferenceEngine );
/** @var ContentHandler $customContentHandler */
$slotDiffRenderer = $customContentHandler->getSlotDiffRenderer( RequestContext::getMain() );
$this->assertInstanceOf( DifferenceEngineSlotDiffRenderer::class, $slotDiffRenderer );
$this->assertSame(
$customDifferenceEngine->objectId,
TestingAccessWrapper::newFromObject( $slotDiffRenderer )->differenceEngine->objectId
);
}
public function testGetSlotDiffRenderer_nobc() {
$this->mergeMwGlobalArrayValue( 'wgHooks', [
'GetSlotDiffRenderer' => [],
] );
// test that B/C renderer does not get used when getSlotDiffRendererInternal is overridden
$customDifferenceEngine = $this->createMock( DifferenceEngine::class );
$customSlotDiffRenderer = $this->getMockBuilder( SlotDiffRenderer::class )
->disableOriginalConstructor()
->getMockForAbstractClass();
$customContentHandler2 = $this->getMockBuilder( ContentHandler::class )
->setConstructorArgs( [ 'bar', [] ] )
->onlyMethods( [ 'createDifferenceEngine', 'getSlotDiffRendererInternal' ] )
->getMockForAbstractClass();
$customContentHandler2->method( 'createDifferenceEngine' )
->willReturn( $customDifferenceEngine );
$customContentHandler2->method( 'getSlotDiffRendererInternal' )
->willReturn( $customSlotDiffRenderer );
/** @var ContentHandler $customContentHandler2 */
$this->hideDeprecated( 'ContentHandler::getSlotDiffRendererInternal' );
$slotDiffRenderer = $customContentHandler2->getSlotDiffRenderer( RequestContext::getMain() );
$this->assertSame( $customSlotDiffRenderer, $slotDiffRenderer );
}
public function testGetSlotDiffRenderer_hook() {
$this->mergeMwGlobalArrayValue( 'wgHooks', [
'GetSlotDiffRenderer' => [],
] );
// test that the hook handler takes precedence
$customDifferenceEngine = $this->createMock( DifferenceEngine::class );
$customContentHandler = $this->getMockBuilder( ContentHandler::class )
->setConstructorArgs( [ 'foo', [] ] )
->onlyMethods( [ 'createDifferenceEngine' ] )
->getMockForAbstractClass();
$customContentHandler->method( 'createDifferenceEngine' )
->willReturn( $customDifferenceEngine );
/** @var ContentHandler $customContentHandler */
$customSlotDiffRenderer = $this->getMockBuilder( SlotDiffRenderer::class )
->disableOriginalConstructor()
->getMockForAbstractClass();
$customContentHandler2 = $this->getMockBuilder( ContentHandler::class )
->setConstructorArgs( [ 'bar', [] ] )
->onlyMethods( [ 'createDifferenceEngine', 'getSlotDiffRendererInternal' ] )
->getMockForAbstractClass();
$customContentHandler2->method( 'createDifferenceEngine' )
->willReturn( $customDifferenceEngine );
$customContentHandler2->method( 'getSlotDiffRendererInternal' )
->willReturn( $customSlotDiffRenderer );
/** @var ContentHandler $customContentHandler2 */
$customSlotDiffRenderer2 = $this->getMockBuilder( SlotDiffRenderer::class )
->disableOriginalConstructor()
->getMockForAbstractClass();
$this->setTemporaryHook( 'GetSlotDiffRenderer',
static function ( $handler, &$slotDiffRenderer ) use ( $customSlotDiffRenderer2 ) {
$slotDiffRenderer = $customSlotDiffRenderer2;
} );
$this->hideDeprecated( 'ContentHandler::getSlotDiffRendererInternal' );
$slotDiffRenderer = $customContentHandler->getSlotDiffRenderer( RequestContext::getMain() );
$this->assertSame( $customSlotDiffRenderer2, $slotDiffRenderer );
$this->hideDeprecated( 'ContentHandler::getSlotDiffRendererInternal' );
$slotDiffRenderer = $customContentHandler2->getSlotDiffRenderer( RequestContext::getMain() );
$this->assertSame( $customSlotDiffRenderer2, $slotDiffRenderer );
}
public static function providerGetPageViewLanguage() {
yield [ NS_FILE, 'sr', 'sr-ec', 'sr-ec' ];
yield [ NS_FILE, 'sr', 'sr', 'sr' ];
yield [ NS_MEDIAWIKI, 'sr-ec', 'sr', 'sr-ec' ];
yield [ NS_MEDIAWIKI, 'sr', 'sr-ec', 'sr' ];
}
/**
* Superseded by OutputPageTest::testGetJsVarsAboutPageLang
*
* @dataProvider providerGetPageViewLanguage
*/
public function testGetPageViewLanguage( $namespace, $lang, $variant, $expected ) {
$contentHandler = $this->getMockBuilder( ContentHandler::class )
->disableOriginalConstructor()
->getMockForAbstractClass();
$title = Title::makeTitle( $namespace, 'SimpleTitle' );
$this->overrideConfigValue( MainConfigNames::DefaultLanguageVariant, $variant );
$this->setUserLang( $lang );
$this->setContentLang( $lang );
$pageViewLanguage = $contentHandler->getPageViewLanguage( $title );
$this->assertEquals( $expected, $pageViewLanguage->getCode() );
}
public static function provideValidateSave() {
yield 'wikitext' => [
new WikitextContent( 'hello world' ),
true
];
yield 'valid json' => [
new JsonContent( '{ "0": "bar" }' ),
true
];
yield 'invalid json' => [
new JsonContent( 'foo' ),
false
];
}
/**
* @dataProvider provideValidateSave
*/
public function testValidateSave( $content, $expectedResult ) {
$page = new PageIdentityValue( 0, 1, 'Foo', PageIdentity::LOCAL );
$contentHandlerFactory = $this->getServiceContainer()->getContentHandlerFactory();
$contentHandler = $contentHandlerFactory->getContentHandler( $content->getModel() );
$validateParams = new ValidationParams( $page, 0 );
$status = $contentHandler->validateSave( $content, $validateParams );
$this->assertEquals( $expectedResult, $status->isOK() );
}
}
PK ! O6
6
5 content/Transform/PreSaveTransformParamsValueTest.phpnu Iw <?php
/**
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* http://www.gnu.org/copyleft/gpl.html
*
* @file
* @since 1.42
*/
namespace MediaWiki\Tests\Content\Transform;
use MediaWiki\Content\Transform\PreSaveTransformParamsValue;
use MediaWiki\Page\PageReference;
use MediaWiki\Parser\ParserOptions;
use MediaWiki\Title\Title;
use MediaWiki\User\User;
use MediaWiki\User\UserIdentity;
use MediaWikiIntegrationTestCase;
/**
* @covers \MediaWiki\Content\Transform\PreSaveTransformParamsValue
* @group Database
*/
class PreSaveTransformParamsValueTest extends MediaWikiIntegrationTestCase {
protected PageReference $page;
protected UserIdentity $user;
protected ParserOptions $parserOptions;
protected function setUp(): void {
parent::setUp();
$this->page = $this->createMock( PageReference::class );
$this->user = $this->createMock( UserIdentity::class );
$this->parserOptions = $this->createMock( ParserOptions::class );
}
public function testConstruct() {
$params = new PreSaveTransformParamsValue( $this->page, $this->user, $this->parserOptions );
$this->assertSame( $this->page, $params->getPage() );
$this->assertSame( $this->user, $params->getUser() );
$this->assertSame( $this->parserOptions, $params->getParserOptions() );
}
public function testGetPage() {
$title = Title::newFromText( 'TestPage' );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$params = new PreSaveTransformParamsValue( $page, $this->user, $this->parserOptions );
$this->assertSame( $page, $params->getPage() );
}
public function testGetUser() {
$user = $this->getTestUser();
$params = new PreSaveTransformParamsValue( $this->page, $user->getUserIdentity(), $this->parserOptions );
$expectedUser = $user->getUserIdentity();
$actualUser = $params->getUser();
$this->assertEquals( $expectedUser->getId(), $actualUser->getId(), 'User IDs do not match' );
$this->assertEquals( $expectedUser->getName(), $actualUser->getName(), 'User names do not match' );
$this->assertEquals( $expectedUser->getWikiId(), $actualUser->getWikiId(), 'Wiki IDs do not match' );
}
/**
* @dataProvider provideParserOptions
*/
public function testGetParserOptions( $options ) {
$title = Title::newFromText( 'TestPage' );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$params = new PreSaveTransformParamsValue( $page, $this->user, $options );
$this->assertSame( $options, $params->getParserOptions() );
}
public function provideParserOptions(): array {
$user = new User();
$options = ParserOptions::newFromUser( $user );
return [
[ $options ],
[ ParserOptions::newFromUser( $user ) ],
];
}
}
PK ! U,h , content/Transform/ContentTransformerTest.phpnu Iw <?php
use MediaWiki\Content\WikitextContent;
use MediaWiki\MainConfigNames;
use MediaWiki\Parser\ParserOptions;
use MediaWiki\Title\Title;
use MediaWiki\User\User;
/**
* @covers \MediaWiki\Content\Transform\ContentTransformer
*/
class ContentTransformerTest extends MediaWikiIntegrationTestCase {
public static function preSaveTransformProvider() {
return [
[
new WikitextContent( 'Test ~~~' ),
'Test [[Special:Contributions/127.0.0.1|127.0.0.1]]'
],
];
}
/**
*
* @dataProvider preSaveTransformProvider
*/
public function testPreSaveTransform( $content, $expectedContainText ) {
$this->overrideConfigValue( MainConfigNames::LanguageCode, 'en' );
$services = $this->getServiceContainer();
$title = Title::makeTitle( NS_MAIN, 'Test' );
$user = new User();
$user->setName( "127.0.0.1" );
$options = ParserOptions::newFromUser( $user );
$newContent = $services->getContentTransformer()->preSaveTransform( $content, $title, $user, $options );
$this->assertSame( $expectedContainText, $newContent->serialize() );
}
public static function preloadTransformProvider() {
return [
[
new WikitextContent( '{{Foo}}<noinclude> censored</noinclude> information <!-- is very secret -->' ),
'{{Foo}} information <!-- is very secret -->'
],
];
}
/**
* @dataProvider preloadTransformProvider
*/
public function testPreloadTransform( $content, $expectedContainText ) {
$services = $this->getServiceContainer();
$title = Title::makeTitle( NS_MAIN, 'Test' );
$options = ParserOptions::newFromAnon();
$newContent = $services->getContentTransformer()->preloadTransform( $content, $title, $options );
$this->assertSame( $expectedContainText, $newContent->serialize() );
}
}
PK ! ( content/JavaScriptContentHandlerTest.phpnu Iw <?php
use MediaWiki\Content\JavaScriptContent;
use MediaWiki\Content\JavaScriptContentHandler;
use MediaWiki\MainConfigNames;
use MediaWiki\Title\Title;
/**
* @covers \MediaWiki\Content\JavaScriptContentHandler
*/
class JavaScriptContentHandlerTest extends MediaWikiLangTestCase {
/**
* @dataProvider provideMakeRedirectContent
*/
public function testMakeRedirectContent( $title, $expected ) {
$this->overrideConfigValues( [
MainConfigNames::Server => '//example.org',
MainConfigNames::Script => '/w/index.php',
] );
$ch = new JavaScriptContentHandler();
$content = $ch->makeRedirectContent( Title::newFromText( $title ) );
$this->assertInstanceOf( JavaScriptContent::class, $content );
$this->assertEquals( $expected, $content->serialize( CONTENT_FORMAT_JAVASCRIPT ) );
}
/**
* This is re-used by JavaScriptContentTest to assert roundtrip
*/
public static function provideMakeRedirectContent() {
return [
'MediaWiki namespace page' => [
'MediaWiki:MonoBook.js',
'/* #REDIRECT */mw.loader.load("//example.org/w/index.php?title=MediaWiki:MonoBook.js&action=raw&ctype=text/javascript");'
],
'User subpage' => [
'User:FooBar/common.js',
'/* #REDIRECT */mw.loader.load("//example.org/w/index.php?title=User:FooBar/common.js&action=raw&ctype=text/javascript");'
],
'Gadget page' => [
'Gadget:FooBaz.js',
'/* #REDIRECT */mw.loader.load("//example.org/w/index.php?title=Gadget:FooBaz.js&action=raw&ctype=text/javascript");'
],
'Unicode basename' => [
'User:😂/unicode.js',
'/* #REDIRECT */mw.loader.load("//example.org/w/index.php?title=User:%F0%9F%98%82/unicode.js&action=raw&ctype=text/javascript");'
],
'Ampersand basename' => [
'User:Penn & Teller/ampersand.js',
'/* #REDIRECT */mw.loader.load("//example.org/w/index.php?title=User:Penn_%26_Teller/ampersand.js&action=raw&ctype=text/javascript");'
],
];
}
}
PK ! Uik k D content/RegistrationContentHandlerFactoryToMediaWikiServicesTest.phpnu Iw <?php
use MediaWiki\Content\CssContentHandler;
use MediaWiki\Content\JavaScriptContentHandler;
use MediaWiki\Content\JsonContentHandler;
use MediaWiki\Content\TextContentHandler;
use MediaWiki\Content\WikitextContentHandler;
use MediaWiki\MainConfigNames;
/**
* @group ContentHandlerFactory
* @covers \MediaWiki\MediaWikiServices::getContentHandlerFactory
*/
class RegistrationContentHandlerFactoryToMediaWikiServicesTest extends MediaWikiIntegrationTestCase {
protected function setUp(): void {
parent::setUp();
$this->overrideConfigValue(
MainConfigNames::ContentHandlers,
[
CONTENT_MODEL_WIKITEXT => [
'class' => WikitextContentHandler::class,
'services' => [
'TitleFactory',
'ParserFactory',
'GlobalIdGenerator',
'LanguageNameUtils',
'LinkRenderer',
'MagicWordFactory',
'ParsoidParserFactory',
],
],
CONTENT_MODEL_JAVASCRIPT => JavaScriptContentHandler::class,
CONTENT_MODEL_JSON => JsonContentHandler::class,
CONTENT_MODEL_CSS => CssContentHandler::class,
CONTENT_MODEL_TEXT => TextContentHandler::class,
'testing' => DummyContentHandlerForTesting::class,
'testing-callbacks' => static function ( $modelId ) {
return new DummyContentHandlerForTesting( $modelId );
},
]
);
}
public function testCallFromService_get_ok(): void {
$this->assertInstanceOf(
\MediaWiki\Content\IContentHandlerFactory::class,
$this->getServiceContainer()->getContentHandlerFactory()
);
$this->assertSame(
[
'wikitext',
'javascript',
'json',
'css',
'text',
'testing',
'testing-callbacks',
],
$this->getServiceContainer()->getContentHandlerFactory()->getContentModels()
);
}
public function testCallFromService_second_same(): void {
$this->assertSame(
$this->getServiceContainer()->getContentHandlerFactory(),
$this->getServiceContainer()->getContentHandlerFactory()
);
}
public function testCallFromService_afterCustomDefine_same(): void {
$factory = $this->getServiceContainer()->getContentHandlerFactory();
$factory->defineContentHandler(
'model name',
DummyContentHandlerForTesting::class
);
$this->assertTrue(
$this->getServiceContainer()
->getContentHandlerFactory()
->isDefinedModel( 'model name' )
);
$this->assertSame(
$factory,
$this->getServiceContainer()->getContentHandlerFactory()
);
}
}
PK ! 6~F F content/WikitextContentTest.phpnu Iw <?php
use MediaWiki\Content\JavaScriptContent;
use MediaWiki\Content\TextContent;
use MediaWiki\Content\WikitextContent;
use MediaWiki\Deferred\LinksUpdate\LinksDeletionUpdate;
use MediaWiki\Parser\Parser;
use MediaWiki\Parser\ParserOptions;
use MediaWiki\Title\Title;
/**
* @group ContentHandler
*
* @group Database
* ^--- needed, because we do need the database to test link updates
* @covers \MediaWiki\Content\WikitextContent
*/
class WikitextContentTest extends TextContentTest {
public const SECTIONS = "Intro
== stuff ==
hello world
== test ==
just a test
== foo ==
more stuff
";
public function newContent( $text ) {
return new WikitextContent( $text );
}
public static function dataGetSection() {
return [
[ self::SECTIONS,
"0",
"Intro"
],
[ self::SECTIONS,
"2",
"== test ==
just a test"
],
[ self::SECTIONS,
"8",
false
],
];
}
/**
* @dataProvider dataGetSection
*/
public function testGetSection( $text, $sectionId, $expectedText ) {
$content = $this->newContent( $text );
$sectionContent = $content->getSection( $sectionId );
if ( is_object( $sectionContent ) ) {
$sectionText = $sectionContent->getText();
} else {
$sectionText = $sectionContent;
}
$this->assertEquals( $expectedText, $sectionText );
}
public static function dataReplaceSection() {
return [
[ self::SECTIONS,
"0",
"No more",
null,
trim( preg_replace( '/^Intro/m', 'No more', self::SECTIONS ) )
],
[ self::SECTIONS,
"",
"No more",
null,
"No more"
],
[ self::SECTIONS,
"2",
"== TEST ==\nmore fun",
null,
trim( preg_replace(
'/^== test ==.*== foo ==/sm', "== TEST ==\nmore fun\n\n== foo ==",
self::SECTIONS
) )
],
[ self::SECTIONS,
"8",
"No more",
null,
self::SECTIONS
],
[ self::SECTIONS,
"new",
"No more",
"New",
trim( self::SECTIONS ) . "\n\n\n== New ==\n\nNo more"
],
];
}
/**
* @dataProvider dataReplaceSection
*/
public function testReplaceSection( $text, $section, $with, $sectionTitle, $expected ) {
$content = $this->newContent( $text );
/** @var WikitextContent $c */
$c = $content->replaceSection( $section, $this->newContent( $with ), $sectionTitle );
$this->assertEquals( $expected, $c ? $c->getText() : null );
}
public function testAddSectionHeader() {
$content = $this->newContent( 'hello world' );
$content = $content->addSectionHeader( 'test' );
$this->assertEquals( "== test ==\n\nhello world", $content->getText() );
$content = $this->newContent( 'hello world' );
$content = $content->addSectionHeader( '' );
$this->assertEquals( "hello world", $content->getText() );
}
public static function dataPreSaveTransform() {
return [
[ 'hello this is ~~~',
"hello this is [[Special:Contributions/127.0.0.1|127.0.0.1]]",
],
[ 'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
],
[ // rtrim
" Foo \n ",
" Foo",
],
];
}
public static function dataGetRedirectTarget() {
return [
[ '#REDIRECT [[Test]]',
'Test',
],
[ '#REDIRECT Test',
null,
],
[ '* #REDIRECT [[Test]]',
null,
],
];
}
public static function dataGetTextForSummary() {
return [
[ "hello\nworld.",
16,
'hello world.',
],
[ 'hello world.',
8,
'hello...',
],
[ '[[hello world]].',
8,
'hel...',
],
];
}
public static function dataIsCountable() {
return [
[ '',
null,
'any',
true
],
[ 'Foo',
null,
'any',
true
],
[ 'Foo',
null,
'link',
false
],
[ 'Foo [[bar]]',
null,
'link',
true
],
[ 'Foo',
true,
'link',
true
],
[ 'Foo [[bar]]',
false,
'link',
false
],
[ '#REDIRECT [[bar]]',
true,
'any',
false
],
[ '#REDIRECT [[bar]]',
true,
'link',
false
],
];
}
public function testMatchMagicWord() {
$mw = $this->getServiceContainer()->getMagicWordFactory()->get( "staticredirect" );
$content = $this->newContent( "#REDIRECT [[FOO]]\n__STATICREDIRECT__" );
$this->assertTrue( $content->matchMagicWord( $mw ), "should have matched magic word" );
$content = $this->newContent( "#REDIRECT [[FOO]]" );
$this->assertFalse(
$content->matchMagicWord( $mw ),
"should not have matched magic word"
);
}
public function testUpdateRedirect() {
$target = Title::makeTitle( NS_MAIN, 'TestUpdateRedirect_target' );
// test with non-redirect page
$content = $this->newContent( "hello world." );
$newContent = $content->updateRedirect( $target );
$this->assertTrue( $content->equals( $newContent ), "content should be unchanged" );
// test with actual redirect
$content = $this->newContent( "#REDIRECT [[Someplace]]" );
$newContent = $content->updateRedirect( $target );
$this->assertFalse( $content->equals( $newContent ), "content should have changed" );
$this->assertTrue( $newContent->isRedirect(), "new content should be a redirect" );
$this->assertEquals(
$target->getFullText(),
$newContent->getRedirectTarget()->getFullText()
);
}
public function testGetModel() {
$content = $this->newContent( "hello world." );
$this->assertEquals( CONTENT_MODEL_WIKITEXT, $content->getModel() );
}
public function testGetContentHandler() {
$content = $this->newContent( "hello world." );
$this->assertEquals( CONTENT_MODEL_WIKITEXT, $content->getContentHandler()->getModelID() );
}
/**
* @covers \MediaWiki\Parser\ParserOptions
*/
public function testRedirectParserOption() {
$title = Title::makeTitle( NS_MAIN, 'TestRedirectParserOption' );
$contentRenderer = $this->getServiceContainer()->getContentRenderer();
// Set up hook and its reporting variables
$wikitext = null;
$redirectTarget = null;
$this->mergeMwGlobalArrayValue( 'wgHooks', [
'InternalParseBeforeLinks' => [
static function ( Parser $parser, $text, $stripState ) use ( &$wikitext, &$redirectTarget ) {
$wikitext = $text;
$redirectTarget = $parser->getOptions()->getRedirectTarget();
}
]
] );
// Test with non-redirect page
$wikitext = false;
$redirectTarget = false;
$content = $this->newContent( 'hello world.' );
$options = ParserOptions::newFromAnon();
$options->setRedirectTarget( $title );
$contentRenderer->getParserOutput( $content, $title, null, $options );
$this->assertEquals( 'hello world.', $wikitext,
'Wikitext passed to hook was not as expected'
);
$this->assertNull( $redirectTarget, 'Redirect seen in hook was not null' );
$this->assertEquals( $title, $options->getRedirectTarget(),
'ParserOptions\' redirectTarget was changed'
);
// Test with a redirect page
$wikitext = false;
$redirectTarget = false;
$content = $this->newContent(
"#REDIRECT [[TestRedirectParserOption/redir]]\nhello redirect."
);
$options = ParserOptions::newFromAnon();
$contentRenderer->getParserOutput( $content, $title, null, $options );
$this->assertEquals(
'hello redirect.',
$wikitext,
'Wikitext passed to hook was not as expected'
);
$this->assertNotEquals(
null,
$redirectTarget,
'Redirect seen in hook was null' );
$this->assertEquals(
'TestRedirectParserOption/redir',
$redirectTarget->getFullText(),
'Redirect seen in hook was not the expected title'
);
$this->assertNull(
$options->getRedirectTarget(),
'ParserOptions\' redirectTarget was changed'
);
}
public static function dataEquals() {
return [
[ new WikitextContent( "hallo" ), null, false ],
[ new WikitextContent( "hallo" ), new WikitextContent( "hallo" ), true ],
[ new WikitextContent( "hallo" ), new JavaScriptContent( "hallo" ), false ],
[ new WikitextContent( "hallo" ), new TextContent( "hallo" ), false ],
[ new WikitextContent( "hallo" ), new WikitextContent( "HALLO" ), false ],
];
}
public static function dataGetDeletionUpdates() {
return [
[
CONTENT_MODEL_WIKITEXT, "hello ''world''\n",
[ LinksDeletionUpdate::class => [] ]
],
[
CONTENT_MODEL_WIKITEXT, "hello [[world test 21344]]\n",
[ LinksDeletionUpdate::class => [] ]
],
// @todo more...?
];
}
}
PK ! N&8 8 - content/JsonContentHandlerIntegrationTest.phpnu Iw <?php
use MediaWiki\Content\JsonContent;
use MediaWiki\Content\JsonContentHandler;
use MediaWiki\Content\ValidationParams;
use MediaWiki\Json\FormatJson;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Page\PageIdentityValue;
use MediaWiki\Parser\ParserOptions;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Title\Title;
/**
* @covers \MediaWiki\Content\JsonContentHandler
*/
class JsonContentHandlerIntegrationTest extends MediaWikiLangTestCase {
public static function provideDataAndParserText() {
return [
[
[],
'<div class="noresize"><table class="mw-json"><tbody><tr><td>' .
'<table class="mw-json"><tbody><tr><td class="mw-json-empty">Empty array</td></tr>'
. '</tbody></table></td></tr></tbody></table></div>'
],
[
(object)[],
'<div class="noresize"><table class="mw-json"><tbody><tr><td class="mw-json-empty">Empty object</td></tr>' .
'</tbody></table></div>'
],
[
(object)[ 'foo' ],
'<div class="noresize"><table class="mw-json"><tbody><tr><th><span>0</span></th>' .
'<td class="mw-json-value">"foo"</td></tr></tbody></table></div>'
],
[
(object)[ 'foo', 'bar' ],
'<div class="noresize"><table class="mw-json"><tbody><tr><th><span>0</span></th>' .
'<td class="mw-json-value">"foo"</td></tr><tr><th><span>1</span></th>' .
'<td class="mw-json-value">"bar"</td></tr></tbody></table></div>'
],
[
(object)[ 'baz' => 'foo', 'bar' ],
'<div class="noresize"><table class="mw-json"><tbody><tr><th><span>baz</span></th>' .
'<td class="mw-json-value">"foo"</td></tr><tr><th><span>0</span></th>' .
'<td class="mw-json-value">"bar"</td></tr></tbody></table></div>'
],
[
(object)[ 'baz' => 1000, 'bar' ],
'<div class="noresize"><table class="mw-json"><tbody><tr><th><span>baz</span></th>' .
'<td class="mw-json-value">1000</td></tr><tr><th><span>0</span></th>' .
'<td class="mw-json-value">"bar"</td></tr></tbody></table></div>'
],
[
(object)[ '<script>alert("evil!")</script>' ],
'<div class="noresize"><table class="mw-json"><tbody><tr><th><span>0</span></th><td class="mw-json-value">"' .
'<script>alert("evil!")</script>"' .
'</td></tr></tbody></table></div>',
],
[
'{ broken JSON ]',
'Invalid JSON: $1',
],
];
}
/**
* @dataProvider provideDataAndParserText
*/
public function testFillParserOutput( $data, $expected ) {
if ( !is_string( $data ) ) {
$data = FormatJson::encode( $data );
}
$title = $this->createMock( Title::class );
$title->method( 'getPageLanguage' )
->willReturn( $this->getServiceContainer()->getContentLanguage() );
$content = new JsonContent( $data );
$contentRenderer = $this->getServiceContainer()->getContentRenderer();
$opts = ParserOptions::newFromAnon();
$parserOutput = $contentRenderer->getParserOutput(
$content,
$title,
null,
$opts,
true
);
$this->assertInstanceOf( ParserOutput::class, $parserOutput );
$this->assertEquals( $expected, $parserOutput->runOutputPipeline( $opts, [] )->getContentHolderText() );
}
public function testValidateSave() {
$handler = new JsonContentHandler();
$validationParams = new ValidationParams(
PageIdentityValue::localIdentity( 123, NS_MEDIAWIKI, 'Config.json' ),
0
);
$validJson = new JsonContent( FormatJson::encode( [ 'test' => 'value' ] ) );
$invalidJson = new JsonContent( '{"key":' );
$this->assertStatusGood( $handler->validateSave( $validJson, $validationParams ) );
$this->assertStatusError( 'invalid-json-data',
$handler->validateSave( $invalidJson, $validationParams ) );
$this->setTemporaryHook(
'JsonValidateSave',
static function ( JsonContent $content, PageIdentity $pageIdentity, StatusValue $status )
{
if ( $pageIdentity->getDBkey() === 'Config.json' &&
!isset( $content->getData()->getValue()->foo ) ) {
$status->fatal( 'missing-key-foo' );
}
}
);
$this->assertStatusError( 'invalid-json-data',
$handler->validateSave( $invalidJson, $validationParams ) );
$this->assertStatusError( 'missing-key-foo',
$handler->validateSave( $validJson, $validationParams ) );
}
}
PK ! 1
1
content/CssContentTest.phpnu Iw <?php
use MediaWiki\Content\Content;
use MediaWiki\Content\CssContent;
use MediaWiki\Content\WikitextContent;
use MediaWiki\MainConfigNames;
/**
* @group ContentHandler
* @group Database
* ^--- needed, because we do need the database to test link updates
* @covers \MediaWiki\Content\CssContent
*/
class CssContentTest extends TextContentTest {
protected function setUp(): void {
parent::setUp();
$this->overrideConfigValue(
MainConfigNames::TextModelsToParse,
[
CONTENT_MODEL_CSS,
]
);
}
public function newContent( $text ) {
return new CssContent( $text );
}
// XXX: currently, preSaveTransform is applied to styles. this may change or become optional.
public static function dataPreSaveTransform() {
return [
[ 'hello this is ~~~',
"hello this is [[Special:Contributions/127.0.0.1|127.0.0.1]]",
],
[ 'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
],
[ " Foo \n ",
" Foo",
],
];
}
public function testGetModel() {
$content = $this->newContent( 'hello world.' );
$this->assertEquals( CONTENT_MODEL_CSS, $content->getModel() );
}
public function testGetContentHandler() {
$content = $this->newContent( 'hello world.' );
$this->assertEquals( CONTENT_MODEL_CSS, $content->getContentHandler()->getModelID() );
}
/**
* Redirects aren't supported
*/
public static function provideUpdateRedirect() {
return [
[
'#REDIRECT [[Someplace]]',
'#REDIRECT [[Someplace]]',
],
];
}
/**
* @dataProvider provideGetRedirectTarget
*/
public function testGetRedirectTarget( $title, $text ) {
$this->overrideConfigValues( [
MainConfigNames::Server => '//example.org',
MainConfigNames::ScriptPath => '/w',
MainConfigNames::Script => '/w/index.php',
] );
$content = new CssContent( $text );
$target = $content->getRedirectTarget();
$this->assertEquals( $title, $target ? $target->getPrefixedText() : null );
}
/**
* Keep this in sync with CssContentHandlerTest::provideMakeRedirectContent()
*/
public static function provideGetRedirectTarget() {
return [
[ 'MediaWiki:MonoBook.css', "/* #REDIRECT */@import url(//example.org/w/index.php?title=MediaWiki:MonoBook.css&action=raw&ctype=text/css);" ],
[ 'User:FooBar/common.css', "/* #REDIRECT */@import url(//example.org/w/index.php?title=User:FooBar/common.css&action=raw&ctype=text/css);" ],
[
'User:😂/unicode.css',
'/* #REDIRECT */@import url(//example.org/w/index.php?title=User:%F0%9F%98%82/unicode.css&action=raw&ctype=text/css);'
],
# No #REDIRECT comment
[ null, "@import url(//example.org/w/index.php?title=Gadget:FooBaz.css&action=raw&ctype=text/css);" ],
# Wrong domain
[ null, "/* #REDIRECT */@import url(//example.com/w/index.php?title=Gadget:FooBaz.css&action=raw&ctype=text/css);" ],
];
// phpcs:enable
}
public static function dataEquals() {
return [
[ new CssContent( 'hallo' ), null, false ],
[ new CssContent( 'hallo' ), new CssContent( 'hallo' ), true ],
[ new CssContent( 'hallo' ), new WikitextContent( 'hallo' ), false ],
[ new CssContent( 'hallo' ), new CssContent( 'HALLO' ), false ],
];
}
/**
* @dataProvider dataEquals
*/
public function testEquals( Content $a, ?Content $b = null, $equal = false ) {
$this->assertEquals( $equal, $a->equals( $b ) );
}
}
PK ! /t - content/TextContentHandlerIntegrationTest.phpnu Iw <?php
use MediaWiki\Content\ContentHandler;
use MediaWiki\Parser\ParserOptions;
use MediaWiki\Title\Title;
use Wikimedia\Parsoid\ParserTests\TestUtils;
/**
* @group ContentHandler
* @group Database
* ^--- needed, because we do need the database to test link updates
* @covers \MediaWiki\Content\TextContentHandler
*/
class TextContentHandlerIntegrationTest extends MediaWikiLangTestCase {
public static function provideGetParserOutput() {
yield 'Basic render' => [
'title' => 'TextContentTest_testGetParserOutput',
'model' => CONTENT_MODEL_TEXT,
'text' => "hello ''world'' & [[stuff]]\n",
'expectedHtml' => "<pre>hello ''world'' & [[stuff]]\n</pre>",
'expectedFields' => [ 'Links' => [] ]
];
yield 'Multi line render' => [
'title' => 'TextContentTest_testGetParserOutput',
'model' => CONTENT_MODEL_TEXT,
'text' => "Test 1\nTest 2\n\nTest 3\n",
'expectedHtml' => "<pre>Test 1\nTest 2\n\nTest 3\n</pre>",
'expectedFields' => [ 'Links' => [] ]
];
}
/**
* @dataProvider provideGetParserOutput
*/
public function testGetParserOutput( $title, $model, $text, $expectedHtml,
$expectedFields = null, $parserOptions = null
) {
$title = Title::newFromText( $title );
$content = ContentHandler::makeContent( $text, $title, $model );
$contentRenderer = $this->getServiceContainer()->getContentRenderer();
if ( $parserOptions === null ) {
$parserOptions = ParserOptions::newFromAnon();
}
$po = $contentRenderer->getParserOutput( $content, $title, null, $parserOptions );
// TODO T371004
$processedPo = $po->runOutputPipeline( $parserOptions, [] );
$html = $processedPo->getContentHolderText();
$html = preg_replace( '#<!--.*?-->#sm', '', $html ); // strip comments
$html = TestUtils::stripParsoidIds( $html );
if ( $expectedHtml !== null ) {
$this->assertEquals( TestUtils::stripParsoidIds( $expectedHtml ), trim( $html ) );
}
if ( $expectedFields ) {
foreach ( $expectedFields as $field => $exp ) {
$getter = 'get' . ucfirst( $field );
$v = $processedPo->$getter();
if ( is_array( $exp ) ) {
$this->assertArrayEquals( $exp, $v );
} else {
$this->assertEquals( $exp, $v );
}
}
}
}
}
PK ! h:H% H% " content/ContentModelChangeTest.phpnu Iw <?php
use MediaWiki\Content\ContentHandler;
use MediaWiki\Content\ContentModelChange;
use MediaWiki\Context\RequestContext;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Page\WikiPageFactory;
use MediaWiki\Permissions\Authority;
use MediaWiki\Permissions\PermissionStatus;
use MediaWiki\Permissions\RateLimiter;
use MediaWiki\Status\Status;
use MediaWiki\Tests\Unit\MockServiceDependenciesTrait;
use MediaWiki\Tests\Unit\Permissions\MockAuthorityTrait;
use MediaWiki\Title\Title;
use Wikimedia\Rdbms\IDBAccessObject;
/**
* TODO convert to a pure unit test
*
* @group Database
* @covers \MediaWiki\Content\ContentModelChange
*
* @author DannyS712
* @method ContentModelChange newServiceInstance(string $serviceClass, array $parameterOverrides)
*/
class ContentModelChangeTest extends MediaWikiIntegrationTestCase {
use MockAuthorityTrait;
use MockServiceDependenciesTrait;
protected function setUp(): void {
parent::setUp();
$this->getExistingTestPage( 'ExistingPage' );
$this->mergeMwGlobalArrayValue( 'wgContentHandlers', [
'testing' => 'DummyContentHandlerForTesting',
] );
}
private function newContentModelChange(
Authority $performer,
WikiPage $page,
string $newModel
) {
return $this->getServiceContainer()
->getContentModelChangeFactory()
->newContentModelChange( $performer, $page, $newModel );
}
/**
* Test that the content model needs to change
*/
public function testChangeNeeded() {
$wikipage = $this->getExistingTestPage( 'ExistingPage' );
$this->assertSame(
'wikitext',
$wikipage->getTitle()->getContentModel(),
'`ExistingPage` should be wikitext'
);
$change = $this->newContentModelChange(
$this->mockRegisteredAuthorityWithPermissions( [ 'editcontentmodel' ] ),
$wikipage,
'wikitext'
);
$status = $change->doContentModelChange(
RequestContext::getMain(),
__METHOD__ . ' comment',
false
);
$this->assertStatusError( 'apierror-nochanges', $status );
}
/**
* Test that the content needs to be valid for the requested model
*/
public function testInvalidContent() {
$invalidJSON = 'Foo\nBar\nEaster egg\nT22281';
$wikipage = $this->getExistingTestPage( 'PageWithTextThatIsNotValidJSON' );
$wikipage->doUserEditContent(
ContentHandler::makeContent( $invalidJSON, $wikipage->getTitle() ),
$this->getTestSysop()->getUser(),
'EditSummaryForThisTest',
EDIT_UPDATE | EDIT_SUPPRESS_RC
);
$this->assertSame(
'wikitext',
$wikipage->getTitle()->getContentModel(),
'`PageWithTextThatIsNotValidJSON` should be wikitext at first'
);
$change = $this->newContentModelChange(
$this->mockRegisteredAuthorityWithPermissions( [ 'editcontentmodel' ] ),
$wikipage,
'json'
);
$status = $change->doContentModelChange(
RequestContext::getMain(),
__METHOD__ . ' comment',
false
);
$this->assertStatusError( 'invalid-json-data', $status );
}
/**
* Test the EditFilterMergedContent hook can be intercepted
*
* @dataProvider provideTestEditFilterMergedContent
* @param string|bool $customMessage Hook message, or false
* @param string $expectedMessage expected fatal
*/
public function testEditFilterMergedContent( $customMessage, $expectedMessage ) {
$wikipage = $this->getExistingTestPage( 'ExistingPage' );
$this->assertSame(
'wikitext',
$wikipage->getTitle()->getContentModel( IDBAccessObject::READ_LATEST ),
'`ExistingPage` should be wikitext'
);
$this->setTemporaryHook( 'EditFilterMergedContent',
static function ( $unused1, $unused2, Status $status ) use ( $customMessage ) {
if ( $customMessage !== false ) {
$status->fatal( $customMessage );
}
return false;
}
);
$change = $this->newContentModelChange(
$this->mockRegisteredAuthorityWithPermissions( [ 'editcontentmodel' ] ),
$wikipage,
'text'
);
$status = $change->doContentModelChange(
RequestContext::getMain(),
__METHOD__ . ' comment',
false
);
$this->assertStatusError( $expectedMessage, $status );
}
public static function provideTestEditFilterMergedContent() {
return [
[ 'DannyS712 objects to this change!', 'DannyS712 objects to this change!' ],
[ false, 'hookaborted' ]
];
}
/**
* Test the ContentModelCanBeUsedOn hook can be intercepted
*/
public function testContentModelCanBeUsedOn() {
$wikipage = $this->getExistingTestPage( 'ExistingPage' );
$wikipage->doUserEditContent(
ContentHandler::makeContent( 'Text', $wikipage->getTitle() ),
$this->getTestSysop()->getUser(),
'Ensure a revision exists',
EDIT_UPDATE | EDIT_SUPPRESS_RC
);
$this->assertSame(
'wikitext',
$wikipage->getTitle()->getContentModel( IDBAccessObject::READ_LATEST ),
'`ExistingPage` should be wikitext'
);
$this->setTemporaryHook( 'ContentModelCanBeUsedOn',
static function ( $unused1, $unused2, &$ok ) {
$ok = false;
return false;
}
);
$change = $this->newContentModelChange(
$this->mockRegisteredAuthorityWithPermissions( [ 'editcontentmodel' ] ),
$wikipage,
'text'
);
$status = $change->doContentModelChange(
RequestContext::getMain(),
__METHOD__ . ' comment',
false
);
$this->assertStatusError( 'apierror-changecontentmodel-cannotbeused', $status );
}
/**
* Test that content handler must support direct editing
*/
public function testNoDirectEditing() {
$title = Title::newFromText( 'Dummy:NoDirectEditing' );
$wikipage = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
$dummyContent = $this->getServiceContainer()
->getContentHandlerFactory()
->getContentHandler( 'testing' )
->makeEmptyContent();
$wikipage->doUserEditContent(
$dummyContent,
$this->getTestSysop()->getUser(),
'EditSummaryForThisTest',
EDIT_NEW | EDIT_SUPPRESS_RC
);
$this->assertSame(
'testing',
$title->getContentModel( IDBAccessObject::READ_LATEST ),
'Dummy:NoDirectEditing should start with the `testing` content model'
);
$change = $this->newContentModelChange(
$this->mockRegisteredAuthorityWithPermissions( [ 'editcontentmodel' ] ),
$wikipage,
'text'
);
$status = $change->doContentModelChange(
RequestContext::getMain(),
__METHOD__ . ' comment',
false
);
$this->assertStatusError(
'apierror-changecontentmodel-nodirectediting',
$status
);
}
public function testCannotApplyTags() {
$this->getServiceContainer()->getChangeTagsStore()->defineTag( 'edit content model tag' );
$change = $this->newContentModelChange(
$this->mockRegisteredAuthorityWithoutPermissions( [ 'applychangetags' ] ),
$this->getExistingTestPage( 'ExistingPage' ),
'text'
);
$status = $change->setTags( [ 'edit content model tag' ] );
$this->assertStatusError(
'tags-apply-no-permission',
$status
);
}
public function testCheckPermissions() {
$wikipage = $this->getExistingTestPage( 'ExistingPage' );
$title = $wikipage->getTitle();
$currentContentModel = $title->getContentModel( IDBAccessObject::READ_LATEST );
$newContentModel = 'text';
$this->assertSame(
'wikitext',
$currentContentModel,
'`ExistingPage` should be wikitext'
);
$performer = $this->mockRegisteredAuthority( static function (
string $permission,
PageIdentity $page,
PermissionStatus $status
) use ( $currentContentModel, $newContentModel ) {
$title = Title::newFromPageIdentity( $page );
if ( $permission === 'editcontentmodel' && $title->hasContentModel( $currentContentModel ) ) {
$status->fatal( 'no edit old content model' );
return false;
}
if ( $permission === 'editcontentmodel' && $title->hasContentModel( $newContentModel ) ) {
$status->fatal( 'no edit new content model' );
return false;
}
if ( $permission === 'edit' && $title->hasContentModel( $currentContentModel ) ) {
$status->fatal( 'no edit at all old content model' );
return false;
}
if ( $permission === 'edit' && $title->hasContentModel( $newContentModel ) ) {
$status->fatal( 'no edit at all new content model' );
return false;
}
return true;
} );
$wpFactory = $this->createMock( WikiPageFactory::class );
$wpFactory->method( 'newFromTitle' )->willReturn( $wikipage );
$change = $this->newServiceInstance(
ContentModelChange::class,
[
'performer' => $performer,
'page' => $wikipage,
'newModel' => $newContentModel,
'wikiPageFactory' => $wpFactory,
]
);
foreach ( [ 'probablyCanChange', 'authorizeChange' ] as $method ) {
$status = $change->$method();
$this->assertArrayEquals(
[
[ 'no edit new content model' ],
[ 'no edit old content model' ],
[ 'no edit at all old content model' ],
[ 'no edit at all new content model' ],
],
$status->toLegacyErrorArray()
);
}
}
public function testCheckPermissionsThrottle() {
$user = $this->getTestUser()->getUser();
$limiter = $this->createNoOpMock( RateLimiter::class, [ 'limit', 'isLimitable' ] );
$limiter->method( 'isLimitable' )->willReturn( true );
$limiter->method( 'limit' )
->willReturnCallback( function ( $user, $action, $incr ) {
if ( $action === 'editcontentmodel' ) {
$this->assertSame( 1, $incr );
return true;
}
return false;
} );
$this->setService( 'RateLimiter', $limiter );
$change = $this->newContentModelChange(
$user,
$this->getNonexistingTestPage( 'NonExistingPage' ),
'text'
);
$status = $change->authorizeChange();
$this->assertFalse( $status->isOK() );
$this->assertTrue( $status->isRateLimitExceeded() );
}
}
PK ! F' F' 1 content/WikitextContentHandlerIntegrationTest.phpnu Iw <?php
use MediaWiki\Content\Renderer\ContentParseParams;
use MediaWiki\Interwiki\ClassicInterwikiLookup;
use MediaWiki\Linker\LinkTarget;
use MediaWiki\MainConfigNames;
use MediaWiki\Parser\ParserOptions;
use MediaWiki\Title\Title;
use MediaWiki\Title\TitleValue;
use Wikimedia\Parsoid\Parsoid;
/**
* @group ContentHandler
* @group Database
* ^--- needed, because we do need the database to test link updates
* @covers \MediaWiki\Content\WikitextContentHandler
*/
class WikitextContentHandlerIntegrationTest extends TextContentHandlerIntegrationTest {
protected function setUp(): void {
parent::setUp();
// Set up temporary interwiki links for 'en' and 'google'
$defaults = [
'iw_local' => 0,
'iw_api' => '/w/api.php',
'iw_url' => ''
];
$this->overrideConfigValue(
MainConfigNames::InterwikiCache,
ClassicInterwikiLookup::buildCdbHash( [
[
'iw_prefix' => 'en',
'iw_url' => 'https://en.wikipedia.org/wiki/$1',
'iw_wikiid' => 'enwiki',
] + $defaults,
[
'iw_prefix' => 'google',
'iw_url' => 'https://google.com/?q=$1',
'iw_wikiid' => 'google',
] + $defaults,
] )
);
}
public static function provideGetParserOutput() {
$commonOptions = [
'collapsibleSections',
'disableContentConversion',
'interfaceMessage',
'isPreview',
'maxIncludeSize',
'suppressSectionEditLinks',
'useParsoid',
'wrapclass',
];
$commonParsoidOptions = array_merge( $commonOptions, [
// Currently no options specific to parsoid parses
] );
$commonLegacyOptions = array_merge( $commonOptions, [
'disableTitleConversion',
'expensiveParserFunctionLimit',
'maxPPExpandDepth',
'maxPPNodeCount',
'suppressTOC',
'targetLanguage',
] );
$parsoidVersion =
'data-mw-parsoid-version="' . Parsoid::version() . '" ' .
'data-mw-html-version="' . Parsoid::defaultHTMLVersion() . '"';
yield 'Basic render' => [
'title' => 'WikitextContentTest_testGetParserOutput',
'model' => CONTENT_MODEL_WIKITEXT,
'text' => "hello ''world''\n",
'expectedHtml' => '<div class="mw-content-ltr mw-parser-output" lang="en" dir="ltr">' . "<p>hello <i>world</i>\n</p></div>",
'expectedFields' => [
'Links' => [
],
'Sections' => [
],
'UsedOptions' => $commonLegacyOptions,
],
];
yield 'Basic Parsoid render' => [
'title' => 'WikitextContentTest_testGetParserOutput',
'model' => CONTENT_MODEL_WIKITEXT,
'text' => "hello ''world''\n",
'expectedHtml' => "<div class=\"mw-content-ltr mw-parser-output\" lang=\"en\" dir=\"ltr\" $parsoidVersion><section data-mw-section-id=\"0\" id=\"mwAQ\"><p id=\"mwAg\">hello <i id=\"mwAw\">world</i></p>\n</section></div>",
'expectedFields' => [
'Links' => [
],
'Sections' => [
],
'UsedOptions' => $commonParsoidOptions,
],
'options' => [ 'useParsoid' => true, 'suppressSectionEditLinks' => true ],
];
yield 'Parsoid render (redirect page)' => [
'title' => 'WikitextContentTest_testGetParserOutput',
'model' => CONTENT_MODEL_WIKITEXT,
'text' => "#REDIRECT [[Main Page]]",
'expectedHtml' => "<div class=\"mw-content-ltr mw-parser-output\" lang=\"en\" dir=\"ltr\" $parsoidVersion><div class=\"redirectMsg\"><p>Redirect to:</p><ul class=\"redirectText\"><li><a href=\"/w/index.php?title=Main_Page&action=edit&redlink=1\" class=\"new\" title=\"Main Page (page does not exist)\">Main Page</a></li></ul></div><section data-mw-section-id=\"0\" id=\"mwAQ\"><link rel=\"mw:PageProp/redirect\" href=\"./Main_Page\" id=\"mwAg\"/></section></div>",
'expectedFields' => [
'Links' => [
[ 'Main_Page' => 0 ],
],
'Sections' => [
],
'UsedOptions' => $commonParsoidOptions,
],
'options' => [ 'useParsoid' => true, 'suppressSectionEditLinks' => true ],
];
yield 'Parsoid render (section edit links)' => [
'title' => 'WikitextContentTest_testGetParserOutput',
'model' => CONTENT_MODEL_WIKITEXT,
'text' => "== Hello ==",
'expectedHtml' => "<div class=\"mw-content-ltr mw-parser-output\" lang=\"en\" dir=\"ltr\" $parsoidVersion id=\"mwAw\">" . '<section data-mw-section-id="0" id="mwAQ"></section><section data-mw-section-id="1" id="mwAg"><div class="mw-heading mw-heading2" id="mwBA"><h2 id="Hello">Hello</h2><span class="mw-editsection" id="mwBQ"><span class="mw-editsection-bracket" id="mwBg">[</span><a href="/w/index.php?title=WikitextContentTest_testGetParserOutput&action=edit§ion=1" title="Edit section: Hello" id="mwBw"><span id="mwCA">edit</span></a><span class="mw-editsection-bracket" id="mwCQ">]</span></span></div></section></div>',
'expectedFields' => [
'Links' => [
],
'Sections' => [
[
'toclevel' => 1,
'level' => '2',
'line' => 'Hello',
'number' => '1',
'index' => '1',
'fromtitle' => 'WikitextContentTest_testGetParserOutput',
'byteoffset' => 0,
'anchor' => 'Hello',
'linkAnchor' => 'Hello',
],
],
'UsedOptions' => $commonParsoidOptions,
],
'options' => [ 'useParsoid' => true ],
];
yield 'Links' => [
'title' => 'WikitextContentTest_testGetParserOutput',
'model' => CONTENT_MODEL_WIKITEXT,
'text' => "[[title that does not really exist]]",
'expectedHtml' => null,
'expectedFields' => [
'Links' => [
[ 'Title_that_does_not_really_exist' => 0, ],
],
'Sections' => [
],
],
];
yield 'TOC' => [
'title' => 'WikitextContentTest_testGetParserOutput',
'model' => CONTENT_MODEL_WIKITEXT,
'text' => "==One==\n==Two==\n==Three==\n==Four==\n<h2>Five</h2>\n===Six+Seven %2525===",
'expectedHtml' => null,
'expectedFields' => [
'Links' => [
],
'Sections' => [
[
'toclevel' => 1,
'level' => '2',
'line' => 'One',
'number' => '1',
'index' => '1',
'fromtitle' => 'WikitextContentTest_testGetParserOutput',
'byteoffset' => 0,
'anchor' => 'One',
'linkAnchor' => 'One',
],
[
'toclevel' => 1,
'level' => '2',
'line' => 'Two',
'number' => '2',
'index' => '2',
'fromtitle' => 'WikitextContentTest_testGetParserOutput',
'byteoffset' => 8,
'anchor' => 'Two',
'linkAnchor' => 'Two',
],
[
'toclevel' => 1,
'level' => '2',
'line' => 'Three',
'number' => '3',
'index' => '3',
'fromtitle' => 'WikitextContentTest_testGetParserOutput',
'byteoffset' => 16,
'anchor' => 'Three',
'linkAnchor' => 'Three',
],
[
'toclevel' => 1,
'level' => '2',
'line' => 'Four',
'number' => '4',
'index' => '4',
'fromtitle' => 'WikitextContentTest_testGetParserOutput',
'byteoffset' => 26,
'anchor' => 'Four',
'linkAnchor' => 'Four',
],
[
'toclevel' => 1,
'level' => '2',
'line' => 'Five',
'number' => '5',
'index' => '',
'fromtitle' => false,
'byteoffset' => null,
'anchor' => 'Five',
'linkAnchor' => 'Five',
],
[
'toclevel' => 2,
'level' => '3',
'line' => 'Six+Seven %2525',
'number' => '5.1',
'index' => '5',
'fromtitle' => 'WikitextContentTest_testGetParserOutput',
'byteoffset' => 49,
'anchor' => 'Six+Seven_%2525',
'linkAnchor' => 'Six+Seven_%252525',
],
],
],
];
}
/**
* @dataProvider provideGetParserOutput
*/
public function testGetParserOutput( $title, $model, $text, $expectedHtml,
$expectedFields = null, $options = null
) {
$this->overrideConfigValues( [
MainConfigNames::ScriptPath => '/w',
MainConfigNames::Script => '/w/index.php',
MainConfigNames::FragmentMode => [ 'html5' ],
] );
$parserOptions = null;
if ( $options ) {
$parserOptions = ParserOptions::newFromAnon();
foreach ( $options as $key => $val ) {
$parserOptions->setOption( $key, $val );
}
}
parent::testGetParserOutput(
$title, $model, $text, $expectedHtml, $expectedFields, $parserOptions
);
}
/**
* @dataProvider provideMakeRedirectContent
* @param LinkTarget $target
* @param string $expectedWT Serialized wikitext form of the content object built
* @param string $expectedTarget Expected target string in the HTML redirect
*/
public function testMakeRedirectContent( LinkTarget $target, string $expectedWT, string $expectedTarget ) {
$handler = $this->getServiceContainer()->getContentHandlerFactory()
->getContentHandler( CONTENT_MODEL_WIKITEXT );
$content = $handler->makeRedirectContent( Title::newFromLinkTarget( $target ) );
$this->assertEquals( $expectedWT, $content->serialize() );
// Check that an appropriate redirect header was added to the
// ParserOutput
$parserOutput = $handler->getParserOutput(
$content,
new ContentParseParams( Title::newMainPage() )
);
$redirectHeader = $parserOutput->getRedirectHeader();
$this->assertStringContainsString( '<div class="redirectMsg">', $redirectHeader );
$this->assertMatchesRegularExpression( '!<a[^<>]+>' . $expectedTarget . '</a>!', $redirectHeader );
}
public static function provideMakeRedirectContent() {
return [
[ new TitleValue( NS_MAIN, 'Hello' ), '#REDIRECT [[Hello]]', 'Hello' ],
[ new TitleValue( NS_TEMPLATE, 'Hello' ), '#REDIRECT [[Template:Hello]]', 'Template:Hello' ],
[ new TitleValue( NS_MAIN, 'Hello', 'section' ), '#REDIRECT [[Hello#section]]', 'Hello#section' ],
[ new TitleValue( NS_USER, 'John doe', 'section' ), '#REDIRECT [[User:John doe#section]]', 'User:John doe#section' ],
[ new TitleValue( NS_MEDIAWIKI, 'FOOBAR' ), '#REDIRECT [[MediaWiki:FOOBAR]]', 'MediaWiki:FOOBAR' ],
[ new TitleValue( NS_CATEGORY, 'Foo' ), '#REDIRECT [[:Category:Foo]]', 'Category:Foo' ],
[ new TitleValue( NS_MAIN, 'en:Foo' ), '#REDIRECT [[en:Foo]]', 'en:Foo' ],
[ new TitleValue( NS_MAIN, 'Foo', '', 'en' ), '#REDIRECT [[:en:Foo]]', 'en:Foo' ],
[
new TitleValue( NS_MAIN, 'Bar', 'fragment', 'google' ),
'#REDIRECT [[google:Bar#fragment]]',
'google:Bar#fragment'
],
];
}
}
PK ! ? ! content/CssContentHandlerTest.phpnu Iw <?php
use MediaWiki\Content\CssContent;
use MediaWiki\Content\CssContentHandler;
use MediaWiki\MainConfigNames;
use MediaWiki\Title\Title;
/**
* @covers \MediaWiki\Content\CssContentHandler
*/
class CssContentHandlerTest extends MediaWikiLangTestCase {
/**
* @dataProvider provideMakeRedirectContent
*/
public function testMakeRedirectContent( int $namespace, string $title, $expected ) {
$this->overrideConfigValues( [
MainConfigNames::Server => '//example.org',
MainConfigNames::Script => '/w/index.php',
] );
$ch = new CssContentHandler();
$content = $ch->makeRedirectContent( Title::makeTitle( $namespace, $title ) );
$this->assertInstanceOf( CssContent::class, $content );
$this->assertEquals( $expected, $content->serialize( CONTENT_FORMAT_CSS ) );
}
/**
* Keep this in sync with CssContentTest::provideGetRedirectTarget()
*/
public static function provideMakeRedirectContent() {
return [
[
NS_MEDIAWIKI,
'MonoBook.css',
"/* #REDIRECT */@import url(//example.org/w/index.php?title=MediaWiki:MonoBook.css&action=raw&ctype=text/css);"
],
[
NS_USER,
'FooBar/common.css',
"/* #REDIRECT */@import url(//example.org/w/index.php?title=User:FooBar/common.css&action=raw&ctype=text/css);"
],
[
NS_USER,
'😂/unicode.css',
'/* #REDIRECT */@import url(//example.org/w/index.php?title=User:%F0%9F%98%82/unicode.css&action=raw&ctype=text/css);'
],
];
// phpcs:enable
}
}
PK ! nED! ! & content/WikitextContentHandlerTest.phpnu Iw <?php
use MediaWiki\Content\FileContentHandler;
use MediaWiki\Content\WikitextContent;
use MediaWiki\Content\WikitextContentHandler;
use MediaWiki\MainConfigNames;
use MediaWiki\Page\PageReferenceValue;
use MediaWiki\Parser\ParserOptions;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Parser\ParserOutputFlags;
use MediaWiki\Title\Title;
use MediaWiki\Title\TitleFactory;
use MediaWiki\User\UserIdentity;
use Wikimedia\Rdbms\IDBAccessObject;
use Wikimedia\TestingAccessWrapper;
/**
* See also unit tests at \MediaWiki\Tests\Unit\WikitextContentHandlerTest
*
* @group ContentHandler
* @covers \MediaWiki\Content\WikitextContentHandler
* @covers \MediaWiki\Content\TextContentHandler
* @covers \MediaWiki\Content\ContentHandler
*/
class WikitextContentHandlerTest extends MediaWikiLangTestCase {
private WikitextContentHandler $handler;
protected function setUp(): void {
parent::setUp();
$this->handler = $this->getServiceContainer()->getContentHandlerFactory()
->getContentHandler( CONTENT_MODEL_WIKITEXT );
}
public static function dataMerge3() {
return [
[
"first paragraph
second paragraph\n",
"FIRST paragraph
second paragraph\n",
"first paragraph
SECOND paragraph\n",
"FIRST paragraph
SECOND paragraph\n",
],
[ "first paragraph
second paragraph\n",
"Bla bla\n",
"Blubberdibla\n",
false,
],
];
}
/**
* @dataProvider dataMerge3
*/
public function testMerge3( $old, $mine, $yours, $expected ) {
$this->markTestSkippedIfNoDiff3();
// test merge
$oldContent = new WikitextContent( $old );
$myContent = new WikitextContent( $mine );
$yourContent = new WikitextContent( $yours );
$merged = $this->handler->merge3( $oldContent, $myContent, $yourContent );
$this->assertEquals( $expected, $merged ? $merged->getText() : $merged );
}
public static function dataGetAutosummary() {
return [
[
'Hello there, world!',
'#REDIRECT [[Foo]]',
0,
'/^Redirected page .*Foo/'
],
[
null,
'Hello world!',
EDIT_NEW,
'/^Created page .*Hello/'
],
[
null,
'',
EDIT_NEW,
'/^Created blank page$/'
],
[
'Hello there, world!',
'',
0,
'/^Blanked/'
],
[
'Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy
eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam
voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet
clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.',
'Hello world!',
0,
'/^Replaced .*Hello/'
],
[
'foo',
'bar',
0,
'/^$/'
],
];
}
/**
* @dataProvider dataGetAutosummary
*/
public function testGetAutosummary( $old, $new, $flags, $expected ) {
$oldContent = $old === null ? null : new WikitextContent( $old );
$newContent = $new === null ? null : new WikitextContent( $new );
$summary = $this->handler->getAutosummary( $oldContent, $newContent, $flags );
$this->assertTrue(
(bool)preg_match( $expected, $summary ),
"Autosummary didn't match expected pattern $expected: $summary"
);
}
public static function dataGetChangeTag() {
return [
[
null,
'#REDIRECT [[Foo]]',
0,
'mw-new-redirect'
],
[
'Lorem ipsum dolor',
'#REDIRECT [[Foo]]',
0,
'mw-new-redirect'
],
[
'#REDIRECT [[Foo]]',
'Lorem ipsum dolor',
0,
'mw-removed-redirect'
],
[
'#REDIRECT [[Foo]]',
'#REDIRECT [[Bar]]',
0,
'mw-changed-redirect-target'
],
[
null,
'Lorem ipsum dolor',
EDIT_NEW,
null // mw-newpage is not defined as a tag
],
[
null,
'',
EDIT_NEW,
null // mw-newblank is not defined as a tag
],
[
'Lorem ipsum dolor',
'',
0,
'mw-blank'
],
[
'Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy
eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam
voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet
clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.',
'Ipsum',
0,
'mw-replace'
],
[
'Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy
eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam
voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet
clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.',
'Duis purus odio, rhoncus et finibus dapibus, facilisis ac urna. Pellentesque
arcu, tristique nec tempus nec, suscipit vel arcu. Sed non dolor nec ligula
congue tempor. Quisque pellentesque finibus orci a molestie. Nam maximus, purus
euismod finibus mollis, dui ante malesuada felis, dignissim rutrum diam sapien.',
0,
null
],
];
}
/**
* @dataProvider dataGetChangeTag
*/
public function testGetChangeTag( $old, $new, $flags, $expected ) {
$this->overrideConfigValue( MainConfigNames::SoftwareTags, [
'mw-new-redirect' => true,
'mw-removed-redirect' => true,
'mw-changed-redirect-target' => true,
'mw-newpage' => true,
'mw-newblank' => true,
'mw-blank' => true,
'mw-replace' => true,
] );
$oldContent = $old === null ? null : new WikitextContent( $old );
$newContent = $new === null ? null : new WikitextContent( $new );
$tag = $this->handler->getChangeTag( $oldContent, $newContent, $flags );
$this->assertSame( $expected, $tag );
}
public function testGetFieldsForSearchIndex() {
$searchEngine = $this->createMock( SearchEngine::class );
$searchEngine->method( 'makeSearchFieldMapping' )
->willReturnCallback( static function ( $name, $type ) {
return new DummySearchIndexFieldDefinition( $name, $type );
} );
$this->hideDeprecated( 'MediaWiki\\Content\\ContentHandler::getForModelID' );
$fields = $this->handler->getFieldsForSearchIndex( $searchEngine );
$this->assertArrayHasKey( 'category', $fields );
$this->assertArrayHasKey( 'external_link', $fields );
$this->assertArrayHasKey( 'outgoing_link', $fields );
$this->assertArrayHasKey( 'template', $fields );
$this->assertArrayHasKey( 'content_model', $fields );
}
public function testDataIndexFieldsFile() {
$mockEngine = $this->createMock( SearchEngine::class );
$title = Title::makeTitle( NS_FILE, 'Somefile.jpg' );
$page = $this->getServiceContainer()->getWikiPageFactory()->newFromTitle( $title );
// Mark the page as not existent to avoid DB queries.
$pageWrapper = TestingAccessWrapper::newFromObject( $page );
$pageWrapper->mLatest = null;
$pageWrapper->mId = 0;
$pageWrapper->mDataLoadedFrom = IDBAccessObject::READ_NORMAL;
$fileHandler = $this->getMockBuilder( FileContentHandler::class )
->disableOriginalConstructor()
->onlyMethods( [ 'getDataForSearchIndex' ] )
->getMock();
$handler = $this->getMockBuilder( WikitextContentHandler::class )
->disableOriginalConstructor()
->onlyMethods( [ 'getFileHandler' ] )
->getMock();
$handler->method( 'getFileHandler' )->willReturn( $fileHandler );
$fileHandler->expects( $this->once() )
->method( 'getDataForSearchIndex' )
->willReturn( [ 'file_text' => 'This is file content' ] );
$data = $handler->getDataForSearchIndex( $page, new ParserOutput( '' ), $mockEngine );
$this->assertArrayHasKey( 'file_text', $data );
$this->assertEquals( 'This is file content', $data['file_text'] );
}
public function testHadSignature() {
$services = $this->getServiceContainer();
$pageObj = PageReferenceValue::localReference( NS_MAIN, __CLASS__ );
// Force a content model in the converted Title to avoid DB queries.
$title = $services->getTitleFactory()->newFromPageReference( $pageObj );
$title->setContentModel( CONTENT_MODEL_WIKITEXT );
$titleFactory = $this->createMock( TitleFactory::class );
$titleFactory->method( 'newFromPageReference' )
->with( $pageObj )
->willReturn( $title );
$this->setService( 'TitleFactory', $titleFactory );
$contentTransformer = $services->getContentTransformer();
$contentRenderer = $services->getContentRenderer();
$this->hideDeprecated( 'AbstractContent::preSaveTransform' );
$content = new WikitextContent( '~~~~' );
$pstContent = $contentTransformer->preSaveTransform(
$content,
$pageObj,
$this->createMock( UserIdentity::class ),
ParserOptions::newFromAnon()
);
$this->assertTrue( $contentRenderer->getParserOutput( $pstContent, $pageObj )->getOutputFlag(
ParserOutputFlags::USER_SIGNATURE
) );
}
}
PK ! ̌Q? 3 content/JavaScriptContentHandlerIntegrationTest.phpnu Iw <?php
/**
* @group ContentHandler
* @group Database
* ^--- needed, because we do need the database to test link updates
* @covers \MediaWiki\Content\JavaScriptContentHandler
*/
class JavaScriptContentHandlerIntegrationTest extends TextContentHandlerIntegrationTest {
public static function provideGetParserOutput() {
yield 'Basic render' => [
'title' => 'MediaWiki:Test.js',
'model' => null,
'text' => "hello <world>\n",
'expectedHtml' => "<pre class=\"mw-code mw-js\" dir=\"ltr\">\nhello <world>\n\n</pre>",
'expectedFields' => [
'Links' => [
],
'Sections' => [
],
],
];
yield 'Links' => [
'title' => 'MediaWiki:Test.js',
'model' => null,
'text' => "hello(); // [[world]]\n",
'expectedHtml' => "<pre class=\"mw-code mw-js\" dir=\"ltr\">\nhello(); // [[world]]\n\n</pre>",
'expectedFields' => [
'Links' => [
[ 'World' => 0, ],
],
'Sections' => [
],
],
];
yield 'TOC' => [
'title' => 'MediaWiki:Test.js',
'model' => null,
'text' => "==One==\n<h2>Two</h2>",
'expectedHtml' => "<pre class=\"mw-code mw-js\" dir=\"ltr\">\n==One==\n<h2>Two</h2>\n</pre>",
'expectedFields' => [
'Links' => [
],
# T307691
'Sections' => [
],
],
];
}
}
PK ! h h content/FallbackContentTest.phpnu Iw <?php
use MediaWiki\Content\Content;
use MediaWiki\Content\FallbackContent;
use MediaWiki\Content\FallbackContentHandler;
use MediaWiki\Content\JavaScriptContent;
use MediaWiki\Content\WikitextContent;
/**
* @group ContentHandler
* @covers \MediaWiki\Content\FallbackContent
* @covers \MediaWiki\Content\FallbackContentHandler
*/
class FallbackContentTest extends MediaWikiLangTestCase {
private const CONTENT_MODEL = 'xyzzy';
protected function setUp(): void {
parent::setUp();
$this->mergeMwGlobalArrayValue(
'wgContentHandlers',
[ self::CONTENT_MODEL => FallbackContentHandler::class ]
);
}
/**
* @param string $data
* @param string $type
*
* @return FallbackContent
*/
public function newContent( $data, $type = self::CONTENT_MODEL ) {
return new FallbackContent( $data, $type );
}
public function testGetRedirectTarget() {
$content = $this->newContent( '#REDIRECT [[Horkyporky]]' );
$this->assertNull( $content->getRedirectTarget() );
}
public function testIsRedirect() {
$content = $this->newContent( '#REDIRECT [[Horkyporky]]' );
$this->assertFalse( $content->isRedirect() );
}
public function testIsCountable() {
$content = $this->newContent( '[[Horkyporky]]' );
$this->assertFalse( $content->isCountable( true ) );
}
public function testGetTextForSummary() {
$content = $this->newContent( 'Horkyporky' );
$this->assertSame( '', $content->getTextForSummary() );
}
public function testGetTextForSearchIndex() {
$content = $this->newContent( 'Horkyporky' );
$this->assertSame( '', $content->getTextForSearchIndex() );
}
public function testCopy() {
$content = $this->newContent( 'hello world.' );
$copy = $content->copy();
$this->assertSame( $content, $copy );
}
public function testGetSize() {
$content = $this->newContent( 'hello world.' );
$this->assertEquals( 12, $content->getSize() );
}
public function testGetData() {
$content = $this->newContent( 'hello world.' );
$this->assertEquals( 'hello world.', $content->getData() );
}
public function testGetNativeData() {
$content = $this->newContent( 'hello world.' );
$this->assertEquals( 'hello world.', $content->getNativeData() );
}
public function testGetWikitextForTransclusion() {
$content = $this->newContent( 'hello world.' );
$this->assertFalse( $content->getWikitextForTransclusion() );
}
public function testGetModel() {
$content = $this->newContent( "hello world.", 'horkyporky' );
$this->assertEquals( 'horkyporky', $content->getModel() );
}
public function testGetContentHandler() {
$this->mergeMwGlobalArrayValue(
'wgContentHandlers',
[ 'horkyporky' => FallbackContentHandler::class ]
);
$content = $this->newContent( "hello world.", 'horkyporky' );
$this->assertInstanceOf( FallbackContentHandler::class, $content->getContentHandler() );
$this->assertEquals( 'horkyporky', $content->getContentHandler()->getModelID() );
}
public static function dataIsEmpty() {
return [
[ '', true ],
[ ' ', false ],
[ '0', false ],
[ 'hallo welt.', false ],
];
}
/**
* @dataProvider dataIsEmpty
*/
public function testIsEmpty( $text, $empty ) {
$content = $this->newContent( $text );
$this->assertEquals( $empty, $content->isEmpty() );
}
public static function provideEquals() {
return [
[ new FallbackContent( "hallo", 'horky' ), null, false ],
[ new FallbackContent( "hallo", 'horky' ), new FallbackContent( "hallo", 'horky' ), true ],
[ new FallbackContent( "hallo", 'horky' ), new FallbackContent( "hallo", 'xyzzy' ), false ],
[ new FallbackContent( "hallo", 'horky' ), new JavaScriptContent( "hallo" ), false ],
[ new FallbackContent( "hallo", 'horky' ), new WikitextContent( "hallo" ), false ],
];
}
/**
* @dataProvider provideEquals
*/
public function testEquals( Content $a, ?Content $b = null, $equal = false ) {
$this->assertEquals( $equal, $a->equals( $b ) );
}
public static function provideConvert() {
return [
[ // #0
'Hallo Welt',
CONTENT_MODEL_WIKITEXT,
'lossless',
'Hallo Welt'
],
[ // #1
'Hallo Welt',
CONTENT_MODEL_WIKITEXT,
'lossless',
'Hallo Welt'
],
[ // #1
'Hallo Welt',
CONTENT_MODEL_CSS,
'lossless',
'Hallo Welt'
],
[ // #1
'Hallo Welt',
CONTENT_MODEL_JAVASCRIPT,
'lossless',
'Hallo Welt'
],
];
}
public function testConvert() {
$content = $this->newContent( 'More horkyporky?' );
$this->assertFalse( $content->convert( CONTENT_MODEL_TEXT ) );
}
public function testSerialize() {
$content = $this->newContent( 'Hörkypörky', 'horkyporky' );
$this->assertSame( 'Hörkypörky', $content->serialize() );
}
}
PK ! w ! content/WikitextStructureTest.phpnu Iw <?php
use MediaWiki\Content\WikitextContent;
use MediaWiki\Content\WikiTextStructure;
use MediaWiki\Title\Title;
/**
* @group Database
* @covers \MediaWiki\Content\WikiTextStructure
*/
class WikitextStructureTest extends MediaWikiLangTestCase {
/**
* Get WikitextStructure for given text
* @param string $text
* @return WikiTextStructure
*/
private function getStructure( $text ) {
$content = new WikitextContent( $text );
$contentRenderer = $this->getServiceContainer()->getContentRenderer();
$parserOutput = $contentRenderer->getParserOutput( $content, Title::makeTitle( NS_MAIN, 'TestTitle' ) );
return new WikiTextStructure( $parserOutput );
}
public function testHeadings() {
$text = <<<END
Some text here
== Heading one ==
Some text
==== heading two ====
More text
=== Applicability of the strict mass-energy equivalence formula, ''E'' = ''mc''<sup>2</sup> ===
and more text
== Wikitext '''in''' [[Heading]] and also <b>html</b> ==
more text
==== See also ====
* Also things to see!
END;
$struct = $this->getStructure( $text );
$headings = $struct->headings();
$this->assertCount( 4, $headings );
$this->assertContains( "Heading one", $headings );
$this->assertContains( "heading two", $headings );
$this->assertContains( "Applicability of the strict mass-energy equivalence formula, E = mc2",
$headings );
$this->assertContains( "Wikitext in Heading and also html", $headings );
}
public function testDefaultSort() {
$text = <<<END
Louise Michel
== Heading one ==
Some text
==== See also ====
* Also things to see!
{{DEFAULTSORT:Michel, Louise}}
END;
$struct = $this->getStructure( $text );
$this->assertEquals( "Michel, Louise", $struct->getDefaultSort() );
}
public function testHeadingsFirst() {
$text = <<<END
== Heading one ==
Some text
==== heading two ====
END;
$struct = $this->getStructure( $text );
$headings = $struct->headings();
$this->assertCount( 2, $headings );
$this->assertContains( "Heading one", $headings );
$this->assertContains( "heading two", $headings );
}
public function testHeadingsNone() {
$text = "This text is completely devoid of headings.";
$struct = $this->getStructure( $text );
$headings = $struct->headings();
$this->assertArrayEquals( [], $headings );
}
public function testTexts() {
$text = <<<END
Opening text is opening.
<h2 class="hello">Then comes header</h2>
Then we got more<br>text
=== And more headers ===
{| class="wikitable"
|-
! Header table
|-
| row in table
|-
| another row in table
|}
END;
$struct = $this->getStructure( $text );
$this->assertEquals( "Opening text is opening.", $struct->getOpeningText() );
$this->assertEquals( "Opening text is opening. Then we got more text",
$struct->getMainText() );
$this->assertEquals( [ "Header table row in table another row in table" ],
$struct->getAuxiliaryText() );
}
public function testPreservesWordSpacing() {
$text = "<dd><dl>foo</dl><dl>bar</dl></dd><p>baz</p>";
$struct = $this->getStructure( $text );
$this->assertEquals( "foo bar baz", $struct->getMainText() );
}
}
PK ! V= ! content/JavaScriptContentTest.phpnu Iw <?php
use MediaWiki\Content\CssContent;
use MediaWiki\Content\JavaScriptContent;
use MediaWiki\MainConfigNames;
use MediaWiki\Title\Title;
/**
* Needs database to do link updates.
*
* @group ContentHandler
* @group Database
* @covers \MediaWiki\Content\JavaScriptContent
*/
class JavaScriptContentTest extends TextContentTest {
public function newContent( $text ) {
return new JavaScriptContent( $text );
}
public function testAddSectionHeader() {
$content = $this->newContent( 'hello world' );
$c = $content->addSectionHeader( 'test' );
$this->assertTrue( $content->equals( $c ) );
}
// XXX: currently, preSaveTransform is applied to scripts. this may change or become optional.
public static function dataPreSaveTransform() {
return [
[ 'hello this is ~~~',
"hello this is [[Special:Contributions/127.0.0.1|127.0.0.1]]",
],
[ 'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
],
[ " Foo \n ",
" Foo",
],
];
}
public static function dataGetRedirectTarget() {
return [
[ '#REDIRECT [[Test]]',
null,
],
[ '#REDIRECT Test',
null,
],
[ '* #REDIRECT [[Test]]',
null,
],
];
}
public static function dataIsCountable() {
return [
[ '',
null,
'any',
true
],
[ 'Foo',
null,
'any',
true
],
[ 'Foo',
null,
'link',
false
],
[ 'Foo [[bar]]',
null,
'link',
false
],
[ 'Foo',
true,
'link',
false
],
[ 'Foo [[bar]]',
false,
'link',
false
],
[ '#REDIRECT [[bar]]',
true,
'any',
true
],
[ '#REDIRECT [[bar]]',
true,
'link',
false
],
];
}
public static function dataGetTextForSummary() {
return [
[ "hello\nworld.",
16,
'hello world.',
],
[ 'hello world.',
8,
'hello...',
],
[ '[[hello world]].',
8,
'[[hel...',
],
];
}
public function testMatchMagicWord() {
$mw = $this->getServiceContainer()->getMagicWordFactory()->get( "staticredirect" );
$content = $this->newContent( "#REDIRECT [[FOO]]\n__STATICREDIRECT__" );
$this->assertFalse(
$content->matchMagicWord( $mw ),
"should not have matched magic word, since it's not wikitext"
);
}
/**
* @dataProvider provideUpdateRedirect
*/
public function testUpdateRedirect( $oldText, $expectedText ) {
$this->overrideConfigValues( [
MainConfigNames::Server => '//example.org',
MainConfigNames::ScriptPath => '/w',
MainConfigNames::Script => '/w/index.php',
MainConfigNames::ResourceBasePath => '/w',
] );
$target = Title::makeTitle( NS_MAIN, 'TestUpdateRedirect_target' );
$content = new JavaScriptContent( $oldText );
$newContent = $content->updateRedirect( $target );
$this->assertEquals( $expectedText, $newContent->getText() );
}
public static function provideUpdateRedirect() {
return [
[
'#REDIRECT [[Someplace]]',
'#REDIRECT [[Someplace]]',
],
[
'/* #REDIRECT */mw.loader.load("//example.org/w/index.php?title=MediaWiki:MonoBook.js&action=raw&ctype=text/javascript");',
'/* #REDIRECT */mw.loader.load("//example.org/w/index.php?title=TestUpdateRedirect_target&action=raw&ctype=text/javascript");'
]
];
}
public function testGetModel() {
$content = $this->newContent( "hello world." );
$this->assertEquals( CONTENT_MODEL_JAVASCRIPT, $content->getModel() );
}
public function testGetContentHandler() {
$content = $this->newContent( "hello world." );
$this->assertEquals( CONTENT_MODEL_JAVASCRIPT, $content->getContentHandler()->getModelID() );
}
// NOTE: Overridden by subclass!
public static function dataEquals() {
return [
[ new JavaScriptContent( "hallo" ), null, false ],
[ new JavaScriptContent( "hallo" ), new JavaScriptContent( "hallo" ), true ],
[ new JavaScriptContent( "hallo" ), new CssContent( "hallo" ), false ],
[ new JavaScriptContent( "hallo" ), new JavaScriptContent( "HALLO" ), false ],
];
}
/**
* @dataProvider provideGetRedirectTarget
*/
public function testGetRedirectTarget( $title, $text ) {
$this->overrideConfigValues( [
MainConfigNames::Server => '//example.org',
MainConfigNames::ScriptPath => '/w',
MainConfigNames::Script => '/w/index.php',
MainConfigNames::ResourceBasePath => '/w',
] );
$content = new JavaScriptContent( $text );
$target = $content->getRedirectTarget();
$this->assertEquals( $title, $target ? $target->getPrefixedText() : null );
}
public static function provideGetRedirectTarget() {
// Roundtrip testing
yield from JavaScriptContentHandlerTest::provideMakeRedirectContent();
// Additional cases that don't roundtrip (errors, and back-compat)
yield 'Missing #REDIRECT comment' => [
null,
'mw.loader.load("//example.org/w/index.php?title=MediaWiki:NoRedirect.js&action=raw&ctype=text/javascript");'
];
yield 'Different domain' => [
null,
'/* #REDIRECT */mw.loader.load("//example.com/w/index.php?title=MediaWiki:OtherWiki.js&action=raw&ctype=text/javascript");'
];
yield 'Encoding before MW 1.42 (T107289)' => [
// \u0026 instead of literal &
'MediaWiki:MonoBook.js',
'/* #REDIRECT */mw.loader.load("//example.org/w/index.php?title=MediaWiki:MonoBook.js\u0026action=raw\u0026ctype=text/javascript");'
];
}
}
PK ! d];/ & content/FallbackContentHandlerTest.phpnu Iw <?php
use MediaWiki\Content\FallbackContent;
use MediaWiki\Content\FallbackContentHandler;
use MediaWiki\Context\RequestContext;
use MediaWiki\Parser\ParserObserver;
use MediaWiki\Parser\ParserOptions;
use MediaWiki\Request\FauxRequest;
use MediaWiki\Title\Title;
/**
* See also unit tests at \MediaWiki\Tests\Unit\FallbackContentHandlerTest
*
* @group ContentHandler
* @covers \MediaWiki\Content\FallbackContentHandler
* @covers \MediaWiki\Content\ContentHandler
*/
class FallbackContentHandlerTest extends MediaWikiLangTestCase {
private const CONTENT_MODEL = 'xyzzy';
protected function setUp(): void {
parent::setUp();
$this->mergeMwGlobalArrayValue(
'wgContentHandlers',
[ self::CONTENT_MODEL => FallbackContentHandler::class ]
);
$this->setService( '_ParserObserver', $this->createMock( ParserObserver::class ) );
}
private function newContent( string $data, string $type = self::CONTENT_MODEL ) {
return new FallbackContent( $data, $type );
}
public function testGetSlotDiffRenderer() {
$context = new RequestContext();
$context->setRequest( new FauxRequest() );
$handler = new FallbackContentHandler( 'horkyporky' );
$this->hideDeprecated( 'ContentHandler::getSlotDiffRendererInternal' );
$slotDiffRenderer = $handler->getSlotDiffRenderer( $context );
$oldContent = $handler->unserializeContent( 'Foo' );
$newContent = $handler->unserializeContent( 'Foo bar' );
$diff = $slotDiffRenderer->getDiff( $oldContent, $newContent );
$this->assertNotEmpty( $diff );
}
public function testGetParserOutput() {
$this->setUserLang( 'en' );
$this->setContentLang( 'qqx' );
$title = $this->createMock( Title::class );
$title->method( 'getPageLanguage' )
->willReturn( $this->getServiceContainer()->getContentLanguage() );
$content = $this->newContent( 'Horkyporky' );
$contentRenderer = $this->getServiceContainer()->getContentRenderer();
$opts = ParserOptions::newFromAnon();
// TODO T371004
$po = $contentRenderer->getParserOutput( $content, $title, null, $opts );
$html = $po->runOutputPipeline( $opts, [] )->getContentHolderText();
$html = preg_replace( '#<!--.*?-->#sm', '', $html ); // strip comments
$this->assertStringNotContainsString( 'Horkyporky', $html );
$this->assertStringNotContainsString( '(unsupported-content-model)', $html );
}
}
PK ! q , content/CssContentHandlerIntegrationTest.phpnu Iw <?php
/**
* @group ContentHandler
* @group Database
* ^--- needed, because we do need the database to test link updates
* @covers \MediaWiki\Content\CssContentHandler
*/
class CssContentHandlerIntegrationTest extends TextContentHandlerIntegrationTest {
public static function provideGetParserOutput() {
yield 'Basic render' => [
'title' => 'MediaWiki:Test.css',
'model' => null,
'text' => "hello <world>x\n",
'expectedHtml' => "<pre class=\"mw-code mw-css\" dir=\"ltr\">\nhello <world>x\n\n</pre>",
'expectedFields' => [
'Links' => [
],
'Sections' => [
],
],
];
yield 'Links' => [
'title' => 'MediaWiki:Test.css',
'model' => null,
'text' => "/* hello [[world]] */\n",
'expectedHtml' => "<pre class=\"mw-code mw-css\" dir=\"ltr\">\n/* hello [[world]] */\n\n</pre>",
'expectedFields' => [
'Links' => [
[ 'World' => 0, ],
],
'Sections' => [
],
],
];
yield 'TOC' => [
'title' => 'MediaWiki:Test.css',
'model' => null,
'text' => "==One==\n<h2>Two</h2>",
'expectedHtml' => "<pre class=\"mw-code mw-css\" dir=\"ltr\">\n==One==\n<h2>Two</h2>\n</pre>",
'expectedFields' => [
'Links' => [
],
# T307691
'Sections' => [
],
]
];
}
}
PK ! q) ) TestUser.phpnu Iw <?php
use MediaWiki\MediaWikiServices;
use MediaWiki\Permissions\Authority;
use MediaWiki\User\User;
use MediaWiki\User\UserIdentity;
use MediaWiki\User\UserIdentityValue;
/**
* Wraps the user object, so we can also retain full access to properties
* like password if we log in via the API.
*/
class TestUser {
/**
* @var string
*/
private $username;
/**
* @var string
*/
private $password;
/**
* @var User
*/
private $user;
private function assertNotReal() {
global $wgDBprefix;
if (
$wgDBprefix !== MediaWikiIntegrationTestCase::DB_PREFIX &&
$wgDBprefix !== ParserTestRunner::DB_PREFIX
) {
throw new RuntimeException( "Can't create user on real database" );
}
}
public function __construct( $username, $realname = 'Real Name',
$email = 'sample@example.com', $groups = []
) {
$this->assertNotReal();
$this->username = $username;
$this->password = 'TestUser';
$this->user = User::newFromName( $this->username );
$this->user->load();
// In an ideal world we'd have a new wiki (or mock data store) for every single test.
// But for now, we just need to create or update the user with the desired properties.
// we particularly need the new password, since we just generated it randomly.
// In core MediaWiki, there is no functionality to delete users, so this is the best we can do.
if ( !$this->user->isRegistered() ) {
// create the user
$this->user = User::createNew(
$this->username, [
"email" => $email,
"real_name" => $realname
]
);
if ( !$this->user ) {
throw new RuntimeException( "Error creating TestUser " . $username );
}
}
// Update the user to use the password and other details
$this->setPassword( $this->password );
$change = $this->setEmail( $email ) ||
$this->setRealName( $realname );
// Adjust groups by adding any missing ones and removing any extras
$userGroupManager = MediaWikiServices::getInstance()->getUserGroupManager();
$currentGroups = $userGroupManager->getUserGroups( $this->user );
$userGroupManager->addUserToMultipleGroups( $this->user, array_diff( $groups, $currentGroups ) );
foreach ( array_diff( $currentGroups, $groups ) as $group ) {
$userGroupManager->removeUserFromGroup( $this->user, $group );
}
if ( $change ) {
// Disable CAS check before saving. The User object may have been initialized from cached
// information that may be out of whack with the database during testing. If tests were
// perfectly isolated, this would not happen. But if it does happen, let's just ignore the
// inconsistency, and just write the data we want - during testing, we are not worried
// about data loss.
$this->user->mTouched = '';
$this->user->saveSettings();
}
}
/**
* @param string $realname
* @return bool
*/
private function setRealName( $realname ) {
if ( $this->user->getRealName() !== $realname ) {
$this->user->setRealName( $realname );
return true;
}
return false;
}
/**
* @param string $email
* @return bool
*/
private function setEmail( string $email ) {
if ( $this->user->getEmail() !== $email ) {
$this->user->setEmail( $email );
return true;
}
return false;
}
/**
* @param string $password
*/
private function setPassword( $password ) {
self::setPasswordForUser( $this->user, $password );
}
/**
* Set the password on a testing user
*
* This assumes we're still using the generic AuthManager config from
* PHPUnitMaintClass::finalSetup(), and just sets the password in the
* database directly.
* @param User $user
* @param string $password
*/
public static function setPasswordForUser( User $user, $password ) {
if ( !$user->getId() ) {
throw new InvalidArgumentException( "Passed User has not been added to the database yet!" );
}
$services = MediaWikiServices::getInstance();
$dbw = $services->getConnectionProvider()->getPrimaryDatabase();
$row = $dbw->newSelectQueryBuilder()
->select( [ 'user_password' ] )
->from( 'user' )
->where( [ 'user_id' => $user->getId() ] )
->caller( __METHOD__ )->fetchRow();
if ( !$row ) {
throw new RuntimeException( "Passed User has an ID but is not in the database?" );
}
$passwordFactory = $services->getPasswordFactory();
if ( !$passwordFactory->newFromCiphertext( $row->user_password )->verify( $password ) ) {
$passwordHash = $passwordFactory->newFromPlaintext( $password );
$dbw->newUpdateQueryBuilder()
->update( 'user' )
->set( [ 'user_password' => $passwordHash->toString() ] )
->where( [ 'user_id' => $user->getId() ] )
->caller( __METHOD__ )->execute();
}
}
/**
* @since 1.25
* @return User
*/
public function getUser() {
return $this->user;
}
/**
* @since 1.39
* @return Authority
*/
public function getAuthority(): Authority {
return $this->user;
}
/**
* @since 1.36
* @return UserIdentity
*/
public function getUserIdentity(): UserIdentity {
return new UserIdentityValue( $this->user->getId(), $this->user->getName() );
}
/**
* @since 1.25
* @return string
*/
public function getPassword() {
return $this->password;
}
}
PK ! gn 0 OutputTransform/OutputTransformStageTestBase.phpnu Iw <?php
namespace MediaWiki\Tests\OutputTransform;
use MediaWiki\Context\RequestContext;
use MediaWiki\MainConfigNames;
use MediaWiki\OutputTransform\OutputTransformStage;
use MediaWiki\Parser\Parsoid\PageBundleParserOutputConverter;
use MediaWikiIntegrationTestCase;
abstract class OutputTransformStageTestBase extends MediaWikiIntegrationTestCase {
abstract public function createStage(): OutputTransformStage;
abstract public function provideShouldRun(): iterable;
abstract public function provideShouldNotRun(): iterable;
abstract public function provideTransform(): iterable;
/**
* @dataProvider provideShouldRun
*/
public function testShouldRun( $parserOutput, $parserOptions, $options ) {
$stage = $this->createStage();
$this->assertTrue( $stage->shouldRun( $parserOutput, $parserOptions, $options ) );
}
public function setUp(): void {
RequestContext::resetMain();
$this->overrideConfigValues( [
MainConfigNames::ScriptPath => '/w',
MainConfigNames::Script => '/w/index.php',
MainConfigNames::Server => '//TEST_SERVER',
MainConfigNames::DefaultSkin => 'fallback'
] );
}
/**
* @dataProvider provideShouldNotRun
*/
public function testShouldNotRun( $parserOutput, $parserOptions, $options ) {
$stage = $this->createStage();
$this->assertFalse( $stage->shouldRun( $parserOutput, $parserOptions, $options ) );
}
/**
* @dataProvider provideTransform
*/
public function testTransform( $parserOutput, $parserOptions, $options, $expected, $message = '' ) {
$stage = $this->createStage();
$result = $stage->transform( $parserOutput, $parserOptions, $options );
// If this has Parsoid internal metadata, clear it in both the expected
// value and the result; these are internal implementation details
// that shouldn't be hardwired into tests.
if ( PageBundleParserOutputConverter::hasPageBundle( $result ) ) {
$key = PageBundleParserOutputConverter::PARSOID_PAGE_BUNDLE_KEY;
$expected->setExtensionData( $key, $result->getExtensionData( $key ) );
}
// Similarly, clear the parse start time to avoid a spurious diff.
$result->clearParseStartTime();
$expected->clearParseStartTime();
$this->assertEquals( $expected, $result, $message );
}
}
PK ! ,; U U 4 OutputTransform/DefaultOutputPipelineFactoryTest.phpnu Iw <?php
namespace MediaWiki\Tests\OutputTransform;
use LogicException;
use MediaWiki\Context\RequestContext;
use MediaWiki\MainConfigNames;
use MediaWiki\Parser\ParserOutput;
use MediaWikiLangTestCase;
/**
* @covers \MediaWiki\OutputTransform\DefaultOutputPipelineFactory
* The tests in this file are copied from the tests in ParserOutputTest. They aim at being the sole version
* once we deprecate ParserOutput::getText. Some of them have been moved to their specific pipeline stage instead.
* @group Database
* ^--- trigger DB shadowing because we are using Title magic
*/
class DefaultOutputPipelineFactoryTest extends MediaWikiLangTestCase {
/**
* @covers \MediaWiki\OutputTransform\DefaultOutputPipelineFactory::buildPipeline
* @dataProvider provideTransform
* @param array $options Options to transform()
* @param string $text Parser text
* @param string $expect Expected output
*/
public function testTransform( $options, $text, $expect ) {
// Avoid other skins affecting the section edit links
$this->overrideConfigValue( MainConfigNames::DefaultSkin, 'fallback' );
RequestContext::resetMain();
$this->overrideConfigValues( [
MainConfigNames::ScriptPath => '/w',
MainConfigNames::Script => '/w/index.php',
MainConfigNames::ParserEnableLegacyHeadingDOM => false,
] );
$po = new ParserOutput( $text );
TestUtils::initSections( $po );
$actual = $this->getServiceContainer()->getDefaultOutputPipeline()
->run( $po, null, $options )->getContentHolderText();
$this->assertSame( $expect, $actual );
}
public static function provideTransform() {
return [
'No options' => [
[], TestUtils::TEST_DOC, <<<EOF
<p>Test document.
</p>
<div id="toc" class="toc" role="navigation" aria-labelledby="mw-toc-heading"><input type="checkbox" role="button" id="toctogglecheckbox" class="toctogglecheckbox" style="display:none" /><div class="toctitle" lang="en" dir="ltr"><h2 id="mw-toc-heading">Contents</h2><span class="toctogglespan"><label class="toctogglelabel" for="toctogglecheckbox"></label></span></div>
<ul>
<li class="toclevel-1 tocsection-1"><a href="#Section_1"><span class="tocnumber">1</span> <span class="toctext">Section 1</span></a></li>
<li class="toclevel-1 tocsection-2"><a href="#Section_2"><span class="tocnumber">2</span> <span class="toctext">Section 2</span></a>
<ul>
<li class="toclevel-2 tocsection-3"><a href="#Section_2.1"><span class="tocnumber">2.1</span> <span class="toctext">Section 2.1</span></a></li>
</ul>
</li>
<li class="toclevel-1 tocsection-4"><a href="#Section_3"><span class="tocnumber">3</span> <span class="toctext">Section 3</span></a></li>
</ul>
</div>
<div class="mw-heading mw-heading2"><h2 id="Section_1">Section 1</h2><span class="mw-editsection"><span class="mw-editsection-bracket">[</span><a href="/w/index.php?title=Test_Page&action=edit§ion=1" title="Edit section: Section 1">edit</a><span class="mw-editsection-bracket">]</span></span></div>
<p>One
</p>
<div class="mw-heading mw-heading2"><h2 id="Section_2">Section 2</h2><span class="mw-editsection"><span class="mw-editsection-bracket">[</span><a href="/w/index.php?title=Test_Page&action=edit§ion=2" title="Edit section: Section 2">edit</a><span class="mw-editsection-bracket">]</span></span></div>
<p>Two
</p>
<div class="mw-heading mw-heading3"><h3 id="Section_2.1">Section 2.1</h3></div>
<p>Two point one
</p>
<div class="mw-heading mw-heading2"><h2 id="Section_3">Section 3</h2><span class="mw-editsection"><span class="mw-editsection-bracket">[</span><a href="/w/index.php?title=Test_Page&action=edit§ion=4" title="Edit section: Section 3">edit</a><span class="mw-editsection-bracket">]</span></span></div>
<p>Three
</p>
EOF
],
'Disable section edit links' => [
[ 'enableSectionEditLinks' => false ], TestUtils::TEST_DOC, <<<EOF
<p>Test document.
</p>
<div id="toc" class="toc" role="navigation" aria-labelledby="mw-toc-heading"><input type="checkbox" role="button" id="toctogglecheckbox" class="toctogglecheckbox" style="display:none" /><div class="toctitle" lang="en" dir="ltr"><h2 id="mw-toc-heading">Contents</h2><span class="toctogglespan"><label class="toctogglelabel" for="toctogglecheckbox"></label></span></div>
<ul>
<li class="toclevel-1 tocsection-1"><a href="#Section_1"><span class="tocnumber">1</span> <span class="toctext">Section 1</span></a></li>
<li class="toclevel-1 tocsection-2"><a href="#Section_2"><span class="tocnumber">2</span> <span class="toctext">Section 2</span></a>
<ul>
<li class="toclevel-2 tocsection-3"><a href="#Section_2.1"><span class="tocnumber">2.1</span> <span class="toctext">Section 2.1</span></a></li>
</ul>
</li>
<li class="toclevel-1 tocsection-4"><a href="#Section_3"><span class="tocnumber">3</span> <span class="toctext">Section 3</span></a></li>
</ul>
</div>
<div class="mw-heading mw-heading2"><h2 id="Section_1">Section 1</h2></div>
<p>One
</p>
<div class="mw-heading mw-heading2"><h2 id="Section_2">Section 2</h2></div>
<p>Two
</p>
<div class="mw-heading mw-heading3"><h3 id="Section_2.1">Section 2.1</h3></div>
<p>Two point one
</p>
<div class="mw-heading mw-heading2"><h2 id="Section_3">Section 3</h2></div>
<p>Three
</p>
EOF
],
'Disable TOC, but wrap' => [
[ 'allowTOC' => false, 'wrapperDivClass' => 'mw-parser-output' ], TestUtils::TEST_DOC, <<<EOF
<div class="mw-content-ltr mw-parser-output" lang="en" dir="ltr"><p>Test document.
</p>
<div class="mw-heading mw-heading2"><h2 id="Section_1">Section 1</h2><span class="mw-editsection"><span class="mw-editsection-bracket">[</span><a href="/w/index.php?title=Test_Page&action=edit§ion=1" title="Edit section: Section 1">edit</a><span class="mw-editsection-bracket">]</span></span></div>
<p>One
</p>
<div class="mw-heading mw-heading2"><h2 id="Section_2">Section 2</h2><span class="mw-editsection"><span class="mw-editsection-bracket">[</span><a href="/w/index.php?title=Test_Page&action=edit§ion=2" title="Edit section: Section 2">edit</a><span class="mw-editsection-bracket">]</span></span></div>
<p>Two
</p>
<div class="mw-heading mw-heading3"><h3 id="Section_2.1">Section 2.1</h3></div>
<p>Two point one
</p>
<div class="mw-heading mw-heading2"><h2 id="Section_3">Section 3</h2><span class="mw-editsection"><span class="mw-editsection-bracket">[</span><a href="/w/index.php?title=Test_Page&action=edit§ion=4" title="Edit section: Section 3">edit</a><span class="mw-editsection-bracket">]</span></span></div>
<p>Three
</p></div>
EOF
],
'Style deduplication disabled' => [
[ 'deduplicateStyles' => false ], TestUtils::TEST_TO_DEDUP, TestUtils::TEST_TO_DEDUP
],
];
// phpcs:enable
}
/**
* @covers \MediaWiki\OutputTransform\DefaultOutputPipelineFactory::buildPipeline
*/
public function testTransform_failsIfNoText() {
$po = new ParserOutput( null );
$this->expectException( LogicException::class );
$this->getServiceContainer()->getDefaultOutputPipeline()
->run( $po, null, [] );
}
}
PK ! q OutputTransform/TestUtils.phpnu Iw <?php
namespace MediaWiki\Tests\OutputTransform;
use MediaWiki\Parser\ParserOutput;
use Wikimedia\Parsoid\Core\SectionMetadata;
use Wikimedia\Parsoid\Core\TOCData;
/**
* Consts and utils used for OutputTransform tests
*/
class TestUtils {
public const TEST_DOC = <<<HTML
<p>Test document.
</p>
<meta property="mw:PageProp/toc" />
<h2 data-mw-anchor="Section_1">Section 1<mw:editsection page="Test Page" section="1">Section 1</mw:editsection></h2>
<p>One
</p>
<h2 data-mw-anchor="Section_2">Section 2<mw:editsection page="Test Page" section="2">Section 2</mw:editsection></h2>
<p>Two
</p>
<h3 data-mw-anchor="Section_2.1">Section 2.1</h3>
<p>Two point one
</p>
<h2 data-mw-anchor="Section_3">Section 3<mw:editsection page="Test Page" section="4">Section 3</mw:editsection></h2>
<p>Three
</p>
HTML;
public const TEST_DOC_WITH_LINKS_LEGACY_MARKUP = <<<HTML
<p>Test document.
</p>
<meta property="mw:PageProp/toc" />
<h2><span class="mw-headline" id="Section_1">Section 1</span><span class="mw-editsection"><span class="mw-editsection-bracket">[</span><a href="/w/index.php?title=Test_Page&action=edit§ion=1" title="Edit section: Section 1">edit</a><span class="mw-editsection-bracket">]</span></span></h2>
<p>One
</p>
<h2><span class="mw-headline" id="Section_2">Section 2</span><span class="mw-editsection"><span class="mw-editsection-bracket">[</span><a href="/w/index.php?title=Test_Page&action=edit§ion=2" title="Edit section: Section 2">edit</a><span class="mw-editsection-bracket">]</span></span></h2>
<p>Two
</p>
<h3><span class="mw-headline" id="Section_2.1">Section 2.1</span></h3>
<p>Two point one
</p>
<h2><span class="mw-headline" id="Section_3">Section 3</span><span class="mw-editsection"><span class="mw-editsection-bracket">[</span><a href="/w/index.php?title=Test_Page&action=edit§ion=4" title="Edit section: Section 3">edit</a><span class="mw-editsection-bracket">]</span></span></h2>
<p>Three
</p>
HTML;
public const TEST_DOC_WITH_LINKS_NEW_MARKUP = <<<HTML
<p>Test document.
</p>
<meta property="mw:PageProp/toc" />
<div class="mw-heading mw-heading2"><h2 id="Section_1">Section 1</h2><span class="mw-editsection"><span class="mw-editsection-bracket">[</span><a href="/w/index.php?title=Test_Page&action=edit§ion=1" title="Edit section: Section 1">edit</a><span class="mw-editsection-bracket">]</span></span></div>
<p>One
</p>
<div class="mw-heading mw-heading2"><h2 id="Section_2">Section 2</h2><span class="mw-editsection"><span class="mw-editsection-bracket">[</span><a href="/w/index.php?title=Test_Page&action=edit§ion=2" title="Edit section: Section 2">edit</a><span class="mw-editsection-bracket">]</span></span></div>
<p>Two
</p>
<div class="mw-heading mw-heading3"><h3 id="Section_2.1">Section 2.1</h3></div>
<p>Two point one
</p>
<div class="mw-heading mw-heading2"><h2 id="Section_3">Section 3</h2><span class="mw-editsection"><span class="mw-editsection-bracket">[</span><a href="/w/index.php?title=Test_Page&action=edit§ion=4" title="Edit section: Section 3">edit</a><span class="mw-editsection-bracket">]</span></span></div>
<p>Three
</p>
HTML;
public const TEST_DOC_WITHOUT_LINKS_LEGACY_MARKUP = <<<HTML
<p>Test document.
</p>
<meta property="mw:PageProp/toc" />
<h2><span class="mw-headline" id="Section_1">Section 1</span></h2>
<p>One
</p>
<h2><span class="mw-headline" id="Section_2">Section 2</span></h2>
<p>Two
</p>
<h3><span class="mw-headline" id="Section_2.1">Section 2.1</span></h3>
<p>Two point one
</p>
<h2><span class="mw-headline" id="Section_3">Section 3</span></h2>
<p>Three
</p>
HTML;
public const TEST_DOC_WITHOUT_LINKS_NEW_MARKUP = <<<HTML
<p>Test document.
</p>
<meta property="mw:PageProp/toc" />
<div class="mw-heading mw-heading2"><h2 id="Section_1">Section 1</h2></div>
<p>One
</p>
<div class="mw-heading mw-heading2"><h2 id="Section_2">Section 2</h2></div>
<p>Two
</p>
<div class="mw-heading mw-heading3"><h3 id="Section_2.1">Section 2.1</h3></div>
<p>Two point one
</p>
<div class="mw-heading mw-heading2"><h2 id="Section_3">Section 3</h2></div>
<p>Three
</p>
HTML;
// In this test, the `>` is not escaped in the 'data-mw-anchor' attribute and tag content, which
// is allowed in HTML, but it's not the serialization used by the Parser. Extensions that modify
// the HTML, e.g. DiscussionTools, can cause this to appear.
public const TEST_DOC_ANGLE_BRACKETS = <<<HTML
<h2 data-mw-anchor=">">><mw:editsection page="Test Page" section="1">></mw:editsection></h2>
HTML;
public const TEST_DOC_ANGLE_BRACKETS_WITH_LINKS_LEGACY_MARKUP = <<<HTML
<h2><span class="mw-headline" id=">">></span><span class="mw-editsection"><span class="mw-editsection-bracket">[</span><a href="/w/index.php?title=Test_Page&action=edit§ion=1" title="Edit section: >">edit</a><span class="mw-editsection-bracket">]</span></span></h2>
HTML;
public const TEST_DOC_ANGLE_BRACKETS_WITH_LINKS_NEW_MARKUP = <<<HTML
<div class="mw-heading mw-heading2"><h2 id=">">></h2><span class="mw-editsection"><span class="mw-editsection-bracket">[</span><a href="/w/index.php?title=Test_Page&action=edit§ion=1" title="Edit section: >">edit</a><span class="mw-editsection-bracket">]</span></span></div>
HTML;
public const TEST_DOC_ANGLE_BRACKETS_WITHOUT_LINKS_LEGACY_MARKUP = <<<HTML
<h2><span class="mw-headline" id=">">></span></h2>
HTML;
public const TEST_DOC_ANGLE_BRACKETS_WITHOUT_LINKS_NEW_MARKUP = <<<HTML
<div class="mw-heading mw-heading2"><h2 id=">">></h2></div>
HTML;
public const TEST_TO_DEDUP = <<<HTML
<p>This is a test document.</p>
<style data-mw-deduplicate="duplicate1">.Duplicate1 {}</style>
<style data-mw-deduplicate="duplicate1">.Duplicate1 {}</style>
<style data-mw-deduplicate="duplicate2">.Duplicate2 {}</style>
<style data-mw-deduplicate="duplicate1">.Duplicate1 {}</style>
<style data-mw-deduplicate="duplicate2">.Duplicate2 {}</style>
<style data-mw-not-deduplicate="duplicate1">.Duplicate1 {}</style>
<style data-mw-deduplicate="duplicate1">.Same-attribute-different-content {}</style>
<style data-mw-deduplicate="duplicate3">.Duplicate1 {}</style>
<style>.Duplicate1 {}</style>
HTML;
public static function initSections( ParserOutput $po ): void {
$po->setTOCData( new TOCData( SectionMetadata::fromLegacy( [
'index' => "1",
'level' => 1,
'toclevel' => 1,
'number' => "1",
'line' => "Section 1",
'anchor' => "Section_1"
] ), SectionMetadata::fromLegacy( [
'index' => "2",
'level' => 1,
'toclevel' => 1,
'number' => "2",
'line' => "Section 2",
'anchor' => "Section_2"
] ), SectionMetadata::fromLegacy( [
'index' => "3",
'level' => 2,
'toclevel' => 2,
'number' => "2.1",
'line' => "Section 2.1",
'anchor' => "Section_2.1"
] ), SectionMetadata::fromLegacy( [
'index' => "4",
'level' => 1,
'toclevel' => 1,
'number' => "3",
'line' => "Section 3",
'anchor' => "Section_3"
] ), ) );
}
}
PK ! ӂ 0 OutputTransform/ContentDOMTransformStageTest.phpnu Iw <?php
namespace MediaWiki\OutputTransform;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\MediaWikiServices;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Parser\Parsoid\PageBundleParserOutputConverter;
use MediaWiki\Tests\OutputTransform\DummyDOMTransformStage;
use PHPUnit\Framework\TestCase;
use Psr\Log\NullLogger;
use Wikimedia\Parsoid\Core\PageBundle;
class ContentDOMTransformStageTest extends TestCase {
public function createStage(): ContentDOMTransformStage {
return new DummyDOMTransformStage(
new ServiceOptions( [] ),
new NullLogger()
);
}
/**
* Regression test for T365036 - checking that a very basic ParserOutput continues serializing after going
* through a ContentDOMTransformStage
* @covers \MediaWiki\OutputTransform\ContentDOMTransformStage::transformDOM
*/
public function testTransform() {
$html = "<div>some output</div>";
$po = new ParserOutput( $html );
PageBundleParserOutputConverter::applyPageBundleDataToParserOutput( new PageBundle( $html ), $po );
$transform = $this->createStage();
$options = [ 'isParsoidContent' => true ];
$po = $transform->transform( $po, null, $options );
$json = MediaWikiServices::getInstance()->getJsonCodec()->serialize( $po );
self::assertStringContainsString( "parsoid-page-bundle", $json );
}
/**
* @covers \MediaWiki\OutputTransform\ContentDOMTransformStage::parsoidTransform
* @covers \MediaWiki\OutputTransform\ContentDOMTransformStage::legacyTransform
*/
public function testTransformOption() {
$html = "<div>some output</div>";
$po = new ParserOutput( $html );
$transform = $this->createStage();
// Legacy, should roundtrip the input
$options = [ 'isParsoidContent' => false ];
$po = $transform->transform( $po, null, $options );
$text = $po->getContentHolderText();
$this->assertEquals( $html, $text );
// Parsoid, input is sullied with rich attributes
$options = [ 'isParsoidContent' => true ];
$po = $transform->transform( $po, null, $options );
$text = $po->getContentHolderText();
$this->assertNotEquals( $html, $text );
// Without PageBundle data, attributes are inlined
self::assertStringContainsString( "data-parsoid", $text );
}
}
PK ! AGZ 8 OutputTransform/Stages/HandleParsoidSectionLinksTest.phpnu Iw <?php
namespace MediaWiki\Tests\OutputTransform\Stages;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Language\Language;
use MediaWiki\OutputTransform\OutputTransformStage;
use MediaWiki\OutputTransform\Stages\HandleParsoidSectionLinks;
use MediaWiki\Parser\ParserOptions;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Parser\Parsoid\PageBundleParserOutputConverter;
use MediaWiki\Tests\OutputTransform\OutputTransformStageTestBase;
use Psr\Log\NullLogger;
use Skin;
use Wikimedia\Parsoid\Core\PageBundle;
use Wikimedia\Parsoid\Core\TOCData;
/** @covers \MediaWiki\OutputTransform\Stages\HandleParsoidSectionLinks */
class HandleParsoidSectionLinksTest extends OutputTransformStageTestBase {
public function createStage(): OutputTransformStage {
return new HandleParsoidSectionLinks(
new ServiceOptions( [] ),
new NullLogger(),
$this->getServiceContainer()->getTitleFactory()
);
}
public function provideShouldRun(): iterable {
yield [ new ParserOutput(), null, [ 'isParsoidContent' => true ] ];
}
public function provideShouldNotRun(): iterable {
yield [ new ParserOutput(), null, [ 'isParsoidContent' => false ] ];
}
private static function newParserOutput(
?string $rawText = null,
?ParserOptions $parserOptions = null,
?TOCData $toc = null,
string ...$flags
) {
$po = new ParserOutput();
if ( $rawText !== null ) {
$po = PageBundleParserOutputConverter::parserOutputFromPageBundle(
new PageBundle( $rawText )
);
}
if ( $parserOptions !== null ) {
$po->setFromParserOptions( $parserOptions );
}
if ( $toc !== null ) {
$po->setTOCData( $toc );
}
foreach ( $flags as $f ) {
$po->setOutputFlag( $f );
}
return $po;
}
public function provideTransform(): iterable {
$skin = $this->createNoOpMock(
Skin::class, [ 'getLanguage', 'doEditSectionLink' ]
);
$skin->method( 'getLanguage' )->willReturn(
$this->createNoOpMock( Language::class )
);
$skin->method( 'doEditSectionLink' )->willReturn(
'!<a id="c">edit</a>!'
);
$options = [
'isParsoidContent' => true,
'enableSectionEditLinks' => true,
'skin' => $skin,
];
$toc = TOCData::fromLegacy( [ [
'toclevel' => 1,
'fromtitle' => 'TestTitle',
'anchor' => 'foo',
] ] );
$input = '<section id="a"><h2 id="foo">Foo</h2>Bar</section>';
$expected = '<section id="a"><div class="mw-heading mw-heading-1" id="mwAQ"><h2 id="foo">Foo</h2></div>Bar</section>';
yield 'Standard Parsoid output: no links' => [
self::newParserOutput( $input, null, $toc ),
null, [ 'enableSectionEditLinks' => false ] + $options,
self::newParserOutput( $expected, null, $toc )
];
$expected = '<section id="a"><div class="mw-heading mw-heading-1" id="mwAQ"><h2 id="foo">Foo</h2>!<a id="c">edit</a>!</div>Bar</section>';
yield 'Standard Parsoid output: with links' => [
self::newParserOutput( $input, null, $toc ),
null, $options,
self::newParserOutput( $expected, null, $toc )
];
// Test collapsible section wrapper (T359001)
$pOpts = ParserOptions::newFromAnon();
$pOpts->setCollapsibleSections();
$expected = '<section id="a"><div class="mw-heading mw-heading-1" id="mwAQ"><h2 id="foo">Foo</h2>!<a id="c">edit</a>!</div><div id="mwAg">Bar</div></section>';
yield 'Standard Parsoid output: collapsible with links' => [
self::newParserOutput( $input, $pOpts, $toc ),
$pOpts, $options,
self::newParserOutput( $expected, $pOpts, $toc )
];
// Test that an existing heading <div> wrapper is reused (T357826)
$input = '<section id="a"><div class="mw-heading mw-heading2" id="b">prefix<h2 id="foo">Foo</h2>suffix</div>Bar</section>';
$expected = '<section id="a"><div class="mw-heading mw-heading2" id="b">prefix<h2 id="foo">Foo</h2>!<a id="c">edit</a>!suffix</div>Bar</section>';
yield 'Output with existing div: with links' => [
self::newParserOutput( $input, null, $toc ),
null, $options,
self::newParserOutput( $expected, null, $toc )
];
// Reused <div> plus collapsible sections
$expected = '<section id="a"><div class="mw-heading mw-heading2" id="b">prefix<h2 id="foo">Foo</h2>!<a id="c">edit</a>!suffix</div><div id="mwAQ">Bar</div></section>';
yield 'Output with existing div: collapsible with links' => [
self::newParserOutput( $input, $pOpts, $toc ),
$pOpts, $options,
self::newParserOutput( $expected, $pOpts, $toc )
];
}
}
PK ! 3I I 3 OutputTransform/Stages/ExpandToAbsoluteUrlsTest.phpnu Iw <?php
namespace MediaWiki\Tests\OutputTransform\Stages;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\OutputTransform\OutputTransformStage;
use MediaWiki\OutputTransform\Stages\ExpandToAbsoluteUrls;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Tests\OutputTransform\OutputTransformStageTestBase;
use Psr\Log\NullLogger;
/**
* @covers \MediaWiki\OutputTransform\Stages\ExpandToAbsoluteUrls
*/
class ExpandToAbsoluteUrlsTest extends OutputTransformStageTestBase {
public function createStage(): OutputTransformStage {
return new ExpandToAbsoluteUrls(
new ServiceOptions( [] ),
new NullLogger()
);
}
public function provideShouldRun(): array {
return [
[ new ParserOutput(), null, [ 'absoluteURLs' => true ] ],
];
}
public function provideShouldNotRun(): array {
return [
[ new ParserOutput(), null, [ 'absoluteURLs' => false ] ],
[ new ParserOutput(), null, [] ],
];
}
public function provideTransform(): array {
$options = [];
return [
[ new ParserOutput( '' ), null, $options, new ParserOutput( '' ) ],
[ new ParserOutput( '<p>test</p>' ), null, $options, new ParserOutput( '<p>test</p>' ) ],
[
new ParserOutput( '<a href="/wiki/Test">test</a>' ),
null, $options,
new ParserOutput( '<a href="//TEST_SERVER/wiki/Test">test</a>' )
],
[
new ParserOutput( '<a href="//TEST_SERVER/wiki/Test">test</a>' ),
null, $options,
new ParserOutput( '<a href="//TEST_SERVER/wiki/Test">test</a>' )
],
[
new ParserOutput( '<a href="https://TEST_SERVER/wiki/Test">test</a>' ),
null, $options,
new ParserOutput( '<a href="https://TEST_SERVER/wiki/Test">test</a>' )
],
[
new ParserOutput( '<a href="https://en.wikipedia.org/wiki/Test">test</a>' ),
null, $options,
new ParserOutput( '<a href="https://en.wikipedia.org/wiki/Test">test</a>' )
],
];
}
}
PK ! )/[ * OutputTransform/Stages/ExtractBodyTest.phpnu Iw <?php
namespace MediaWiki\Tests\OutputTransform\Stages;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\OutputTransform\OutputTransformStage;
use MediaWiki\OutputTransform\Stages\ExtractBody;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Parser\Parsoid\ParsoidParser;
use MediaWiki\Tests\OutputTransform\OutputTransformStageTestBase;
use Psr\Log\NullLogger;
/**
* @covers \MediaWiki\OutputTransform\Stages\ExtractBody
*/
class ExtractBodyTest extends OutputTransformStageTestBase {
public function createStage(): OutputTransformStage {
$urlUtils = $this->getServiceContainer()->getUrlUtils();
return new ExtractBody( new ServiceOptions( [] ), new NullLogger(), $urlUtils, null );
}
public function provideShouldRun(): array {
return [
[ new ParserOutput(), null, [ 'isParsoidContent' => true ] ],
];
}
public function provideShouldNotRun(): array {
return [
[ new ParserOutput(), null, [ 'isParsoidContent' => false ] ],
[ new ParserOutput(), null, [] ],
];
}
public function provideTransform(): array {
$pageTemplate = <<<EOF
<!DOCTYPE html>
<html><head><base href="https://www.example.com/w/"/></head><body>__BODY__
</body></html>
EOF;
$testData = [
[
"title" => "Foo",
"body" => "<p><a href=\"./Hello\">hello</a></p>",
"result" => "<p><a href=\"https://www.example.com/w/Hello\">hello</a></p>\n"
],
// Rest of these tests ensure that self-page cite fragments are converted to fragment urls
// Tests different title scenarios to exercise edge cases
[
"title" => "Foo",
"body" => "<p><a href=\"./Foo#cite1\">hello</a><a href=\"./Foo/Bar#cite1\">boo</a></p>",
"result" => "<p><a href=\"#cite1\">hello</a><a href=\"https://www.example.com/w/Foo/Bar#cite1\">boo</a></p>\n"
],
// hrefs have db-key normalization of titles - test that output isn't tripped by that
[
"title" => "Foo_Bar Baz",
"body" => "<p><a href=\"./Foo_Bar_Baz#cite1\">hello</a></p>",
"result" => "<p><a href=\"#cite1\">hello</a></p>\n"
],
[
"title" => "Foo+Bar",
"body" => "<p><a href=\"./Foo+Bar#cite1\">hello</a></p>",
"result" => "<p><a href=\"#cite1\">hello</a></p>\n"
],
[
"title" => "Foo/Bar",
"body" => "<p><a href=\"./Foo/Bar#cite1\">hello</a></p>",
"result" => "<p><a href=\"#cite1\">hello</a></p>\n"
],
[
"title" => "Foo/Bar'Baz",
"body" => "<p><a href=\"./Foo/Bar'Baz#cite1\">hello</a></p>",
"result" => "<p><a href=\"#cite1\">hello</a></p>\n"
],
[
"title" => 'Foo/Bar"Baz',
"body" => "<p><a href='./Foo/Bar\"Baz#cite1'>hello</a></p>",
"result" => "<p><a href=\"#cite1\">hello</a></p>\n"
]
];
$opts = [];
$tests = [];
// Set test title in parser output extension data
foreach ( $testData as $t ) {
$titleDBKey = strtr( $t['title'], ' ', '_' );
$text = str_replace( "__BODY__", $t['body'], $pageTemplate );
$poInput = new ParserOutput( $text );
$poOutput = new ParserOutput( $t['result'] );
$poInput->setExtensionData( ParsoidParser::PARSOID_TITLE_KEY, $titleDBKey );
$poOutput->setExtensionData( ParsoidParser::PARSOID_TITLE_KEY, $titleDBKey );
$tests[] = [ $poInput, null, $opts, $poOutput ];
}
return $tests;
}
}
PK ! R 0 OutputTransform/Stages/DeduplicateStylesTest.phpnu Iw <?php
namespace MediaWiki\Tests\OutputTransform\Stages;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\OutputTransform\OutputTransformStage;
use MediaWiki\OutputTransform\Stages\DeduplicateStyles;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Tests\OutputTransform\OutputTransformStageTestBase;
use MediaWiki\Tests\OutputTransform\TestUtils;
use Psr\Log\NullLogger;
/**
* @covers \MediaWiki\OutputTransform\Stages\DeduplicateStyles
*/
class DeduplicateStylesTest extends OutputTransformStageTestBase {
public function createStage(): OutputTransformStage {
return new DeduplicateStyles(
new ServiceOptions( [] ),
new NullLogger()
);
}
public function provideShouldRun(): array {
return( [
[ new ParserOutput(), null, [ 'deduplicateStyles' => true ] ],
[ new ParserOutput(), null, [] ],
] );
}
public function provideShouldNotRun(): array {
return( [
[ new ParserOutput(), null, [ 'deduplicateStyles' => false ] ],
] );
}
public function provideTransform(): array {
$dedup = <<<EOF
<p>This is a test document.</p>
<style data-mw-deduplicate="duplicate1">.Duplicate1 {}</style>
<link rel="mw-deduplicated-inline-style" href="mw-data:duplicate1">
<style data-mw-deduplicate="duplicate2">.Duplicate2 {}</style>
<link rel="mw-deduplicated-inline-style" href="mw-data:duplicate1">
<link rel="mw-deduplicated-inline-style" href="mw-data:duplicate2">
<style data-mw-not-deduplicate="duplicate1">.Duplicate1 {}</style>
<link rel="mw-deduplicated-inline-style" href="mw-data:duplicate1">
<style data-mw-deduplicate="duplicate3">.Duplicate1 {}</style>
<style>.Duplicate1 {}</style>
EOF;
$po = new ParserOutput( TestUtils::TEST_TO_DEDUP );
$expected = new ParserOutput( $dedup );
$opts = [];
return [
[ $po, null, $opts, $expected ]
];
}
}
PK ! C / OutputTransform/Stages/HandleTOCMarkersTest.phpnu Iw <?php
namespace MediaWiki\Tests\OutputTransform\Stages;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Language\Language;
use MediaWiki\OutputTransform\OutputTransformStage;
use MediaWiki\OutputTransform\Stages\HandleTOCMarkers;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Tests\OutputTransform\OutputTransformStageTestBase;
use MediaWiki\Tests\OutputTransform\TestUtils;
use Psr\Log\NullLogger;
use Skin;
/**
* @covers \MediaWiki\OutputTransform\Stages\HandleTOCMarkers
*/
class HandleTOCMarkersTest extends OutputTransformStageTestBase {
public function createStage(): OutputTransformStage {
return new HandleTOCMarkers(
new ServiceOptions( [] ),
new NullLogger(),
$this->getServiceContainer()->getTidy()
);
}
public function provideShouldRun(): array {
return [
[ new ParserOutput(), null, [] ],
[ new ParserOutput(), null, [ 'allowTOC' => false, 'injectTOC' => false ] ],
[ new ParserOutput(), null, [ 'allowTOC' => false, 'injectTOC' => true ] ],
[ new ParserOutput(), null, [ 'allowTOC' => true, 'injectTOC' => true ] ],
[ new ParserOutput(), null, [ 'injectTOC' => true ] ],
[ new ParserOutput(), null, [ 'allowTOC' => true ] ],
];
}
public function provideShouldNotRun(): array {
return [
[ new ParserOutput(), null, [ 'allowTOC' => true, 'injectTOC' => false ] ]
];
}
public function provideTransform(): iterable {
$lang = $this->createNoOpMock(
Language::class, [ 'getCode', 'getHtmlCode', 'getDir' ]
);
$lang->method( 'getCode' )->willReturn( 'en' );
$lang->method( 'getHtmlCode' )->willReturn( 'en' );
$lang->method( 'getDir' )->willReturn( 'ltr' );
$skin = $this->createNoOpMock(
Skin::class, [ 'getLanguage' ]
);
$skin->method( 'getLanguage' )->willReturn( $lang );
$withToc = <<<EOF
<p>Test document.
</p>
<div id="toc" class="toc" role="navigation" aria-labelledby="mw-toc-heading"><input type="checkbox" role="button" id="toctogglecheckbox" class="toctogglecheckbox" style="display:none" /><div class="toctitle" lang="en" dir="ltr"><h2 id="mw-toc-heading">Contents</h2><span class="toctogglespan"><label class="toctogglelabel" for="toctogglecheckbox"></label></span></div>
<ul>
<li class="toclevel-1 tocsection-1"><a href="#Section_1"><span class="tocnumber">1</span> <span class="toctext">Section 1</span></a></li>
<li class="toclevel-1 tocsection-2"><a href="#Section_2"><span class="tocnumber">2</span> <span class="toctext">Section 2</span></a>
<ul>
<li class="toclevel-2 tocsection-3"><a href="#Section_2.1"><span class="tocnumber">2.1</span> <span class="toctext">Section 2.1</span></a></li>
</ul>
</li>
<li class="toclevel-1 tocsection-4"><a href="#Section_3"><span class="tocnumber">3</span> <span class="toctext">Section 3</span></a></li>
</ul>
</div>
<h2 data-mw-anchor="Section_1">Section 1<mw:editsection page="Test Page" section="1">Section 1</mw:editsection></h2>
<p>One
</p>
<h2 data-mw-anchor="Section_2">Section 2<mw:editsection page="Test Page" section="2">Section 2</mw:editsection></h2>
<p>Two
</p>
<h3 data-mw-anchor="Section_2.1">Section 2.1</h3>
<p>Two point one
</p>
<h2 data-mw-anchor="Section_3">Section 3<mw:editsection page="Test Page" section="4">Section 3</mw:editsection></h2>
<p>Three
</p>
EOF;
$withoutToc = <<<EOF
<p>Test document.
</p>
<h2 data-mw-anchor="Section_1">Section 1<mw:editsection page="Test Page" section="1">Section 1</mw:editsection></h2>
<p>One
</p>
<h2 data-mw-anchor="Section_2">Section 2<mw:editsection page="Test Page" section="2">Section 2</mw:editsection></h2>
<p>Two
</p>
<h3 data-mw-anchor="Section_2.1">Section 2.1</h3>
<p>Two point one
</p>
<h2 data-mw-anchor="Section_3">Section 3<mw:editsection page="Test Page" section="4">Section 3</mw:editsection></h2>
<p>Three
</p>
EOF;
$poTest1 = new ParserOutput( TestUtils::TEST_DOC );
TestUtils::initSections( $poTest1 );
$expectedWith = new ParserOutput( $withToc );
TestUtils::initSections( $expectedWith );
yield [ $poTest1, null, [
'userLang' => $lang,
'skin' => $skin,
'allowTOC' => true,
'injectTOC' => true
], $expectedWith, 'should insert TOC' ];
$poTest2 = new ParserOutput( TestUtils::TEST_DOC );
TestUtils::initSections( $poTest2 );
$expectedWithout = new ParserOutput( $withoutToc );
TestUtils::initSections( $expectedWithout );
yield [ $poTest2, null, [ 'allowTOC' => false ], $expectedWithout, 'should not insert TOC' ];
$poTest3 = new ParserOutput( TestUtils::TEST_DOC . '<meta property="mw:PageProp/toc" />' );
TestUtils::initSections( $poTest3 );
$expectedWith = new ParserOutput( $withToc );
TestUtils::initSections( $expectedWith );
yield [ $poTest3, null, [
'userLang' => $lang,
'skin' => $skin,
'allowTOC' => true,
'injectTOC' => true
], $expectedWith, 'should insert TOC only once' ];
}
}
PK ! .= 1 OutputTransform/Stages/AddWrapperDivClassTest.phpnu Iw <?php
namespace MediaWiki\Tests\OutputTransform\Stages;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\OutputTransform\OutputTransformStage;
use MediaWiki\OutputTransform\Stages\AddWrapperDivClass;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Tests\OutputTransform\OutputTransformStageTestBase;
use MediaWiki\Tests\OutputTransform\TestUtils;
use Psr\Log\NullLogger;
/**
* @covers \MediaWiki\OutputTransform\Stages\AddWrapperDivClass
*/
class AddWrapperDivClassTest extends OutputTransformStageTestBase {
public function createStage(): OutputTransformStage {
return new AddWrapperDivClass(
new ServiceOptions( [] ),
new NullLogger(),
$this->getServiceContainer()->getLanguageFactory(),
$this->getServiceContainer()->getContentLanguage()
);
}
public function provideShouldRun(): array {
return( [
[ new ParserOutput(), null, [ 'wrapperDivClass' => 'some string' ] ]
] );
}
public function provideShouldNotRun(): array {
return( [
[ new ParserOutput(), null, [ 'wrapperDivClass' => '' ] ],
[ new ParserOutput(), null, [] ]
] );
}
public function provideTransform(): array {
$opts = [ 'wrapperDivClass' => 'mw-parser-output' ];
$po = new ParserOutput( TestUtils::TEST_DOC );
$wrappedText = <<<EOF
<div class="mw-content-ltr mw-parser-output" lang="en" dir="ltr"><p>Test document.
</p>
<meta property="mw:PageProp/toc" />
<h2 data-mw-anchor="Section_1">Section 1<mw:editsection page="Test Page" section="1">Section 1</mw:editsection></h2>
<p>One
</p>
<h2 data-mw-anchor="Section_2">Section 2<mw:editsection page="Test Page" section="2">Section 2</mw:editsection></h2>
<p>Two
</p>
<h3 data-mw-anchor="Section_2.1">Section 2.1</h3>
<p>Two point one
</p>
<h2 data-mw-anchor="Section_3">Section 3<mw:editsection page="Test Page" section="4">Section 3</mw:editsection></h2>
<p>Three
</p></div>
EOF;
$expected = new ParserOutput( $wrappedText );
return [
[ $po, null, $opts, $expected ]
];
}
}
PK ! UC
C
= OutputTransform/Stages/ExecutePostCacheTransformHooksTest.phpnu Iw <?php
namespace MediaWiki\Tests\OutputTransform\Stages;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Context\RequestContext;
use MediaWiki\MainConfigNames;
use MediaWiki\OutputTransform\Stages\ExecutePostCacheTransformHooks;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Tests\OutputTransform\TestUtils;
use Psr\Log\NullLogger;
/**
* This test does not extend OutputTransformStageTestBase because we're explicitly testing that
* the options are modified during the pipeline run.
* @covers \MediaWiki\OutputTransform\Stages\ExecutePostCacheTransformHooks
*/
class ExecutePostCacheTransformHooksTest extends \MediaWikiIntegrationTestCase {
public function createStage(): ExecutePostCacheTransformHooks {
return new ExecutePostCacheTransformHooks(
new ServiceOptions( [] ),
new NullLogger(),
$this->getServiceContainer()->getHookContainer()
);
}
/**
* @covers \MediaWiki\OutputTransform\Stages\ExecutePostCacheTransformHooks::transform
*/
public function testTransform(): void {
// Avoid other skins affecting the section edit links
$this->overrideConfigValue( MainConfigNames::DefaultSkin, 'fallback' );
RequestContext::resetMain();
$this->overrideConfigValues( [
MainConfigNames::ScriptPath => '/w',
MainConfigNames::Script => '/w/index.php',
MainConfigNames::ParserEnableLegacyHeadingDOM => false,
] );
// This tests that the options are modified by the PostCacheTransformHookRunner (if it is not run, or if
// the options are not modified, the test fails)
$po = new ParserOutput( TestUtils::TEST_DOC );
$expected = new ParserOutput( TestUtils::TEST_DOC_WITH_LINKS_NEW_MARKUP );
$this->getServiceContainer()->getHookContainer()->register( 'ParserOutputPostCacheTransform',
static function ( ParserOutput $out, &$text, array &$options ) {
$options['enableSectionEditLinks'] = true;
}
);
// T358103: VisualEditor will change the section edit links causing a test failure.
$this->clearHook( 'SkinEditSectionLinks' );
$pipeline = $this->getServiceContainer()->getDefaultOutputPipeline();
$res = $pipeline->run( $po, null,
[
'allowTOC' => true,
'injectTOC' => false,
'enableSectionEditLinks' => false,
'userLang' => null,
'skin' => null,
'unwrap' => false,
'wrapperDivClass' => '',
'deduplicateStyles' => false,
'absoluteURLs' => false,
'includeDebugInfo' => false,
]
);
$res->clearParseStartTime();
$expected->clearParseStartTime();
$this->assertEquals( $expected, $res );
}
/**
* @covers \MediaWiki\OutputTransform\Stages\ExecutePostCacheTransformHooks::shouldRun
*/
public function testShouldRun() {
$transform = $this->createStage();
$this->getServiceContainer()
->getHookContainer()
->register( 'ParserOutputPostCacheTransform',
static function ( ParserOutput $out, &$text, array &$options ) {
$options['enableSectionEditLinks'] = true;
} );
$options = [];
self::assertTrue( $transform->shouldRun( new ParserOutput(), null, $options ) );
}
/**
* @covers \MediaWiki\OutputTransform\Stages\ExecutePostCacheTransformHooks::shouldRun
*/
public function testShouldNotRun() {
$transform = $this->createStage();
$this->getServiceContainer()->getHookContainer()->clear( 'ParserOutputPostCacheTransform' );
$options = [];
self::assertFalse( $transform->shouldRun( new ParserOutput(), null, $options ) );
}
}
PK ! .I| | . OutputTransform/Stages/RenderDebugInfoTest.phpnu Iw <?php
namespace MediaWiki\Tests\OutputTransform\Stages;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\OutputTransform\OutputTransformStage;
use MediaWiki\OutputTransform\Stages\RenderDebugInfo;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Tests\OutputTransform\OutputTransformStageTestBase;
use Psr\Log\NullLogger;
/**
* @covers \MediaWiki\OutputTransform\Stages\RenderDebugInfo
*/
class RenderDebugInfoTest extends OutputTransformStageTestBase {
public function createStage(): OutputTransformStage {
return new RenderDebugInfo(
new ServiceOptions( [] ),
new NullLogger(),
$this->getServiceContainer()->getHookContainer()
);
}
public function provideShouldRun(): array {
return [
[ new ParserOutput(), null, [ 'includeDebugInfo' => true ] ],
];
}
public function provideShouldNotRun(): array {
return [
[ new ParserOutput(), null, [] ],
[ new ParserOutput(), null, [ 'includeDebugInfo' => false ] ],
];
}
/**
* TODO this only covers the addition of the report, not the content of the report itself. Expanding this
* test may be a good idea.
*/
public function provideTransform(): array {
$text = <<<EOF
<!DOCTYPE html>
<html><head><title>Main Page hello