setMwGlobals( [
'wgUseMediaWikiUIEverywhere' => false,
] );
$contLangObj = Language::factory( 'en' );
// Hardcode namespaces during test runs,
// so that html output based on existing namespaces
// can be properly evaluated.
$contLangObj->setNamespaces( [
-2 => 'Media',
-1 => 'Special',
0 => '',
1 => 'Talk',
2 => 'User',
3 => 'User_talk',
4 => 'MyWiki',
5 => 'MyWiki_Talk',
6 => 'File',
7 => 'File_talk',
8 => 'MediaWiki',
9 => 'MediaWiki_talk',
10 => 'Template',
11 => 'Template_talk',
14 => 'Category',
15 => 'Category_talk',
100 => 'Custom',
101 => 'Custom_talk',
] );
$this->setContentLang( $contLangObj );
$userLangObj = Language::factory( 'es' );
$userLangObj->setNamespaces( [
-2 => "Medio",
-1 => "Especial",
0 => "",
1 => "Discusión",
2 => "Usuario",
3 => "Usuario discusión",
4 => "Wiki",
5 => "Wiki discusión",
6 => "Archivo",
7 => "Archivo discusión",
8 => "MediaWiki",
9 => "MediaWiki discusión",
10 => "Plantilla",
11 => "Plantilla discusión",
12 => "Ayuda",
13 => "Ayuda discusión",
14 => "Categoría",
15 => "Categoría discusión",
100 => "Personalizado",
101 => "Personalizado discusión",
] );
$this->setUserLang( $userLangObj );
$this->restoreWarnings = false;
}
protected function tearDown() {
Language::factory( 'en' )->resetNamespaces();
if ( $this->restoreWarnings ) {
$this->restoreWarnings = false;
Wikimedia\restoreWarnings();
}
parent::tearDown();
}
/**
* @expectedException PHPUnit_Framework_Error_Notice
* @expectedExceptionMessage given element name with space
* @covers Html::openElement
*/
public function testOpenElement() {
Html::openElement( 'span id="x"' );
}
/**
* @covers Html::element
* @covers Html::rawElement
* @covers Html::openElement
* @covers Html::closeElement
*/
public function testElementBasics() {
$this->assertEquals(
'',
Html::element( 'img', null, '' ),
'Self-closing tag for short-tag elements'
);
$this->assertEquals(
'',
Html::element( 'element', null, null ),
'Close tag for empty element (null, null)'
);
$this->assertEquals(
'',
Html::element( 'element', [], '' ),
'Close tag for empty element (array, string)'
);
}
public function dataXmlMimeType() {
return [
// ( $mimetype, $isXmlMimeType )
# HTML is not an XML MimeType
[ 'text/html', false ],
# XML is an XML MimeType
[ 'text/xml', true ],
[ 'application/xml', true ],
# XHTML is an XML MimeType
[ 'application/xhtml+xml', true ],
# Make sure other +xml MimeTypes are supported
# SVG is another random MimeType even though we don't use it
[ 'image/svg+xml', true ],
# Complete random other MimeTypes are not XML
[ 'text/plain', false ],
];
}
/**
* @dataProvider dataXmlMimeType
* @covers Html::isXmlMimeType
*/
public function testXmlMimeType( $mimetype, $isXmlMimeType ) {
$this->assertEquals( $isXmlMimeType, Html::isXmlMimeType( $mimetype ) );
}
/**
* @covers Html::expandAttributes
*/
public function testExpandAttributesSkipsNullAndFalse() {
# ## EMPTY ########
$this->assertEmpty(
Html::expandAttributes( [ 'foo' => null ] ),
'skip keys with null value'
);
$this->assertEmpty(
Html::expandAttributes( [ 'foo' => false ] ),
'skip keys with false value'
);
$this->assertEquals(
' foo=""',
Html::expandAttributes( [ 'foo' => '' ] ),
'keep keys with an empty string'
);
}
/**
* @covers Html::expandAttributes
*/
public function testExpandAttributesForBooleans() {
$this->assertEquals(
'',
Html::expandAttributes( [ 'selected' => false ] ),
'Boolean attributes do not generates output when value is false'
);
$this->assertEquals(
'',
Html::expandAttributes( [ 'selected' => null ] ),
'Boolean attributes do not generates output when value is null'
);
$this->assertEquals(
' selected=""',
Html::expandAttributes( [ 'selected' => true ] ),
'Boolean attributes have no value when value is true'
);
$this->assertEquals(
' selected=""',
Html::expandAttributes( [ 'selected' ] ),
'Boolean attributes have no value when value is true (passed as numerical array)'
);
}
/**
* @covers Html::expandAttributes
*/
public function testExpandAttributesForNumbers() {
$this->assertEquals(
' value="1"',
Html::expandAttributes( [ 'value' => 1 ] ),
'Integer value is cast to a string'
);
$this->assertEquals(
' value="1.1"',
Html::expandAttributes( [ 'value' => 1.1 ] ),
'Float value is cast to a string'
);
}
/**
* @covers Html::expandAttributes
*/
public function testExpandAttributesForObjects() {
$this->assertEquals(
' value="stringValue"',
Html::expandAttributes( [ 'value' => new HtmlTestValue() ] ),
'Object value is converted to a string'
);
}
/**
* Test for Html::expandAttributes()
* Please note it output a string prefixed with a space!
* @covers Html::expandAttributes
*/
public function testExpandAttributesVariousExpansions() {
# ## NOT EMPTY ####
$this->assertEquals(
' empty_string=""',
Html::expandAttributes( [ 'empty_string' => '' ] ),
'Empty string is always quoted'
);
$this->assertEquals(
' key="value"',
Html::expandAttributes( [ 'key' => 'value' ] ),
'Simple string value needs no quotes'
);
$this->assertEquals(
' one="1"',
Html::expandAttributes( [ 'one' => 1 ] ),
'Number 1 value needs no quotes'
);
$this->assertEquals(
' zero="0"',
Html::expandAttributes( [ 'zero' => 0 ] ),
'Number 0 value needs no quotes'
);
}
/**
* Html::expandAttributes has special features for HTML
* attributes that use space separated lists and also
* allows arrays to be used as values.
* @covers Html::expandAttributes
*/
public function testExpandAttributesListValueAttributes() {
# ## STRING VALUES
$this->assertEquals(
' class="redundant spaces here"',
Html::expandAttributes( [ 'class' => ' redundant spaces here ' ] ),
'Normalization should strip redundant spaces'
);
$this->assertEquals(
' class="foo bar"',
Html::expandAttributes( [ 'class' => 'foo bar foo bar bar' ] ),
'Normalization should remove duplicates in string-lists'
);
# ## "EMPTY" ARRAY VALUES
$this->assertEquals(
' class=""',
Html::expandAttributes( [ 'class' => [] ] ),
'Value with an empty array'
);
$this->assertEquals(
' class=""',
Html::expandAttributes( [ 'class' => [ null, '', ' ', ' ' ] ] ),
'Array with null, empty string and spaces'
);
# ## NON-EMPTY ARRAY VALUES
$this->assertEquals(
' class="foo bar"',
Html::expandAttributes( [ 'class' => [
'foo',
'bar',
'foo',
'bar',
'bar',
] ] ),
'Normalization should remove duplicates in the array'
);
$this->assertEquals(
' class="foo bar"',
Html::expandAttributes( [ 'class' => [
'foo bar',
'bar foo',
'foo',
'bar bar',
] ] ),
'Normalization should remove duplicates in string-lists in the array'
);
}
/**
* Test feature added by r96188, let pass attributes values as
* a PHP array. Restricted to class,rel, accesskey.
* @covers Html::expandAttributes
*/
public function testExpandAttributesSpaceSeparatedAttributesWithBoolean() {
$this->assertEquals(
' class="booltrue one"',
Html::expandAttributes( [ 'class' => [
'booltrue' => true,
'one' => 1,
# Method use isset() internally, make sure we do discard
# attributes values which have been assigned well known values
'emptystring' => '',
'boolfalse' => false,
'zero' => 0,
'null' => null,
] ] )
);
}
/**
* How do we handle duplicate keys in HTML attributes expansion?
* We could pass a "class" the values: 'GREEN' and array( 'GREEN' => false )
* The latter will take precedence.
*
* Feature added by r96188
* @covers Html::expandAttributes
*/
public function testValueIsAuthoritativeInSpaceSeparatedAttributesArrays() {
$this->assertEquals(
' class=""',
Html::expandAttributes( [ 'class' => [
'GREEN',
'GREEN' => false,
'GREEN',
] ] )
);
}
/**
* @covers Html::expandAttributes
* @expectedException MWException
*/
public function testExpandAttributes_ArrayOnNonListValueAttribute_ThrowsException() {
// Real-life test case found in the Popups extension (see Gerrit cf0fd64),
// when used with an outdated BetaFeatures extension (see Gerrit deda1e7)
Html::expandAttributes( [
'src' => [
'ltr' => 'ltr.svg',
'rtl' => 'rtl.svg'
]
] );
}
/**
* @covers Html::namespaceSelector
* @covers Html::namespaceSelectorOptions
*/
public function testNamespaceSelector() {
$this->assertEquals(
'',
Html::namespaceSelector(),
'Basic namespace selector without custom options'
);
$this->assertEquals(
'' . "\u{00A0}" .
'',
Html::namespaceSelector(
[ 'selected' => '2', 'all' => 'all', 'label' => 'Select a namespace:' ],
[ 'name' => 'wpNamespace', 'id' => 'mw-test-namespace' ]
),
'Basic namespace selector with custom values'
);
$this->assertEquals(
'' . "\u{00A0}" .
'',
Html::namespaceSelector(
[ 'label' => 'Select a namespace:' ]
),
'Basic namespace selector with a custom label but no id attribtue for the
'
);
$this->assertEquals(
Html::errorBox( 'err', '0' ),
'0
err'
);
}
/**
* @covers Html::successBox
* @covers Html::messageBox
*/
public function testSuccessBox() {
$this->assertEquals(
Html::successBox( 'great' ),
'great
'
);
$this->assertEquals(
Html::successBox( '' ),
''
);
}
/**
* List of input element types values introduced by HTML5
* Full list at https://www.w3.org/TR/html-markup/input.html
*/
public static function provideHtml5InputTypes() {
$types = [
'datetime',
'datetime-local',
'date',
'month',
'time',
'week',
'number',
'range',
'email',
'url',
'search',
'tel',
'color',
];
$cases = [];
foreach ( $types as $type ) {
$cases[] = [ $type ];
}
return $cases;
}
/**
* Test out Html::element drops or enforces default value
* @covers Html::dropDefaults
* @dataProvider provideElementsWithAttributesHavingDefaultValues
*/
public function testDropDefaults( $expected, $element, $attribs, $message = '' ) {
$this->assertEquals( $expected, Html::element( $element, $attribs ), $message );
}
public static function provideElementsWithAttributesHavingDefaultValues() {
# Use cases in a concise format:
# , , [, ]
# Will be mapped to Html::element()
$cases = [];
# ## Generic cases, match $attribDefault static array
$cases[] = [ '',
'area', [ 'shape' => 'rect' ]
];
$cases[] = [ '',
'button', [ 'formaction' => 'GET' ]
];
$cases[] = [ '',
'button', [ 'formenctype' => 'application/x-www-form-urlencoded' ]
];
$cases[] = [ '',
'canvas', [ 'height' => '150' ]
];
$cases[] = [ '',
'canvas', [ 'width' => '300' ]
];
# Also check with numeric values
$cases[] = [ '',
'canvas', [ 'height' => 150 ]
];
$cases[] = [ '',
'canvas', [ 'width' => 300 ]
];
$cases[] = [ '',
'form', [ 'action' => 'GET' ]
];
$cases[] = [ '',
'form', [ 'autocomplete' => 'on' ]
];
$cases[] = [ '',
'form', [ 'enctype' => 'application/x-www-form-urlencoded' ]
];
$cases[] = [ '',
'input', [ 'formaction' => 'GET' ]
];
$cases[] = [ '',
'input', [ 'type' => 'text' ]
];
$cases[] = [ '',
'keygen', [ 'keytype' => 'rsa' ]
];
$cases[] = [ '',
'link', [ 'media' => 'all' ]
];
$cases[] = [ '',
'menu', [ 'type' => 'list' ]
];
$cases[] = [ '',
'script', [ 'type' => 'text/javascript' ]
];
$cases[] = [ '',
'style', [ 'media' => 'all' ]
];
$cases[] = [ '',
'style', [ 'type' => 'text/css' ]
];
$cases[] = [ '',
'textarea', [ 'wrap' => 'soft' ]
];
# ## SPECIFIC CASES
#
$cases[] = [ '',
'link', [ 'type' => 'text/css' ]
];
# specific handling
$cases[] = [ '',
'input', [ 'type' => 'checkbox', 'value' => 'on' ],
'Default value "on" is stripped of checkboxes',
];
$cases[] = [ '',
'input', [ 'type' => 'radio', 'value' => 'on' ],
'Default value "on" is stripped of radio buttons',
];
$cases[] = [ '',
'input', [ 'type' => 'submit', 'value' => 'Submit' ],
'Default value "Submit" is kept on submit buttons (for possible l10n issues)',
];
$cases[] = [ '',
'input', [ 'type' => 'color', 'value' => '' ],
];
$cases[] = [ '',
'input', [ 'type' => 'range', 'value' => '' ],
];
#