tests/phpunit/includes/content/TextContentTest.php

   1 <?php
   2
   3 /**
   4  * @group ContentHandler
   5  * @group Database
   6  *        ^--- needed, because we do need the database to test link updates
   7  */
   8 class TextContentTest extends MediaWikiLangTestCase {
   9         protected $context;
  10
  11         protected function setUp() {
  12                 parent::setUp();
  13
  14                 // Anon user
  15                 $user = new User();
  16                 $user->setName( '127.0.0.1' );
  17
  18                 $this->context = new RequestContext( new FauxRequest() );
  19                 $this->context->setTitle( Title::newFromText( 'Test' ) );
  20                 $this->context->setUser( $user );
  21
  22                 $this->setMwGlobals( [
  23                         'wgUser' => $user,
  24                         'wgTextModelsToParse' => [
  25                                 CONTENT_MODEL_WIKITEXT,
  26                                 CONTENT_MODEL_CSS,
  27                                 CONTENT_MODEL_JAVASCRIPT,
  28                         ],
  29                         'wgUseTidy' => false,
  30                         'wgCapitalLinks' => true,
  31                         'wgHooks' => [], // bypass hook ContentGetParserOutput that force custom rendering
  32                 ] );
  33
  34                 MWTidy::destroySingleton();
  35         }
  36
  37         protected function tearDown() {
  38                 MWTidy::destroySingleton();
  39                 parent::tearDown();
  40         }
  41
  42         public function newContent( $text ) {
  43                 return new TextContent( $text );
  44         }
  45
  46         public static function dataGetParserOutput() {
  47                 return [
  48                         [
  49                                 'TextContentTest_testGetParserOutput',
  50                                 CONTENT_MODEL_TEXT,
  51                                 "hello ''world'' & [[stuff]]\n", "hello ''world'' &amp; [[stuff]]",
  52                                 [
  53                                         'Links' => []
  54                                 ]
  55                         ],
  56                         // TODO: more...?
  57                 ];
  58         }
  59
  60         /**
  61          * @dataProvider dataGetParserOutput
  62          * @covers TextContent::getParserOutput
  63          */
  64         public function testGetParserOutput( $title, $model, $text, $expectedHtml,
  65                 $expectedFields = null
  66         ) {
  67                 $title = Title::newFromText( $title );
  68                 $content = ContentHandler::makeContent( $text, $title, $model );
  69
  70                 $po = $content->getParserOutput( $title );
  71
  72                 $html = $po->getText();
  73                 $html = preg_replace( '#<!--.*?-->#sm', '', $html ); // strip comments
  74
  75                 $this->assertEquals( $expectedHtml, trim( $html ) );
  76
  77                 if ( $expectedFields ) {
  78                         foreach ( $expectedFields as $field => $exp ) {
  79                                 $f = 'get' . ucfirst( $field );
  80                                 $v = call_user_func( [ $po, $f ] );
  81
  82                                 if ( is_array( $exp ) ) {
  83                                         $this->assertArrayEquals( $exp, $v );
  84                                 } else {
  85                                         $this->assertEquals( $exp, $v );
  86                                 }
  87                         }
  88                 }
  89
  90                 // TODO: assert more properties
  91         }
  92
  93         public static function dataPreSaveTransform() {
  94                 return [
  95                         [
  96                                 # 0: no signature resolution
  97                                 'hello this is ~~~',
  98                                 'hello this is ~~~',
  99                         ],
 100                         [
 101                                 # 1: rtrim
 102                                 " Foo \n ",
 103                                 ' Foo',
 104                         ],
 105                 ];
 106         }
 107
 108         /**
 109          * @dataProvider dataPreSaveTransform
 110          * @covers TextContent::preSaveTransform
 111          */
 112         public function testPreSaveTransform( $text, $expected ) {
 113                 global $wgContLang;
 114
 115                 $options = ParserOptions::newFromUserAndLang( $this->context->getUser(), $wgContLang );
 116
 117                 $content = $this->newContent( $text );
 118                 $content = $content->preSaveTransform(
 119                         $this->context->getTitle(),
 120                         $this->context->getUser(),
 121                         $options
 122                 );
 123
 124                 $this->assertEquals( $expected, $content->getNativeData() );
 125         }
 126
 127         public static function dataPreloadTransform() {
 128                 return [
 129                         [
 130                                 'hello this is ~~~',
 131                                 'hello this is ~~~',
 132                         ],
 133                 ];
 134         }
 135
 136         /**
 137          * @dataProvider dataPreloadTransform
 138          * @covers TextContent::preloadTransform
 139          */
 140         public function testPreloadTransform( $text, $expected ) {
 141                 global $wgContLang;
 142                 $options = ParserOptions::newFromUserAndLang( $this->context->getUser(), $wgContLang );
 143
 144                 $content = $this->newContent( $text );
 145                 $content = $content->preloadTransform( $this->context->getTitle(), $options );
 146
 147                 $this->assertEquals( $expected, $content->getNativeData() );
 148         }
 149
 150         public static function dataGetRedirectTarget() {
 151                 return [
 152                         [ '#REDIRECT [[Test]]',
 153                                 null,
 154                         ],
 155                 ];
 156         }
 157
 158         /**
 159          * @dataProvider dataGetRedirectTarget
 160          * @covers TextContent::getRedirectTarget
 161          */
 162         public function testGetRedirectTarget( $text, $expected ) {
 163                 $content = $this->newContent( $text );
 164                 $t = $content->getRedirectTarget();
 165
 166                 if ( is_null( $expected ) ) {
 167                         $this->assertNull( $t, "text should not have generated a redirect target: $text" );
 168                 } else {
 169                         $this->assertEquals( $expected, $t->getPrefixedText() );
 170                 }
 171         }
 172
 173         /**
 174          * @dataProvider dataGetRedirectTarget
 175          * @covers TextContent::isRedirect
 176          */
 177         public function testIsRedirect( $text, $expected ) {
 178                 $content = $this->newContent( $text );
 179
 180                 $this->assertEquals( !is_null( $expected ), $content->isRedirect() );
 181         }
 182
 183         /**
 184          * @todo Test needs database! Should be done by a test class in the Database group.
 185          */
 186         /*
 187         public function getRedirectChain() {
 188                 $text = $this->getNativeData();
 189                 return Title::newFromRedirectArray( $text );
 190         }
 191         */
 192
 193         /**
 194          * @todo Test needs database! Should be done by a test class in the Database group.
 195          */
 196         /*
 197         public function getUltimateRedirectTarget() {
 198                 $text = $this->getNativeData();
 199                 return Title::newFromRedirectRecurse( $text );
 200         }
 201         */
 202
 203         public static function dataIsCountable() {
 204                 return [
 205                         [ '',
 206                                 null,
 207                                 'any',
 208                                 true
 209                         ],
 210                         [ 'Foo',
 211                                 null,
 212                                 'any',
 213                                 true
 214                         ],
 215                         [ 'Foo',
 216                                 null,
 217                                 'comma',
 218                                 false
 219                         ],
 220                         [ 'Foo, bar',
 221                                 null,
 222                                 'comma',
 223                                 false
 224                         ],
 225                 ];
 226         }
 227
 228         /**
 229          * @dataProvider dataIsCountable
 230          * @group Database
 231          * @covers TextContent::isCountable
 232          */
 233         public function testIsCountable( $text, $hasLinks, $mode, $expected ) {
 234                 $this->setMwGlobals( 'wgArticleCountMethod', $mode );
 235
 236                 $content = $this->newContent( $text );
 237
 238                 $v = $content->isCountable( $hasLinks, $this->context->getTitle() );
 239
 240                 $this->assertEquals(
 241                         $expected,
 242                         $v,
 243                         'isCountable() returned unexpected value ' . var_export( $v, true )
 244                                 . ' instead of ' . var_export( $expected, true )
 245                                 . " in mode `$mode` for text \"$text\""
 246                 );
 247         }
 248
 249         public static function dataGetTextForSummary() {
 250                 return [
 251                         [ "hello\nworld.",
 252                                 16,
 253                                 'hello world.',
 254                         ],
 255                         [ 'hello world.',
 256                                 8,
 257                                 'hello...',
 258                         ],
 259                         [ '[[hello world]].',
 260                                 8,
 261                                 '[[hel...',
 262                         ],
 263                 ];
 264         }
 265
 266         /**
 267          * @dataProvider dataGetTextForSummary
 268          * @covers TextContent::getTextForSummary
 269          */
 270         public function testGetTextForSummary( $text, $maxlength, $expected ) {
 271                 $content = $this->newContent( $text );
 272
 273                 $this->assertEquals( $expected, $content->getTextForSummary( $maxlength ) );
 274         }
 275
 276         /**
 277          * @covers TextContent::getTextForSearchIndex
 278          */
 279         public function testGetTextForSearchIndex() {
 280                 $content = $this->newContent( 'hello world.' );
 281
 282                 $this->assertEquals( 'hello world.', $content->getTextForSearchIndex() );
 283         }
 284
 285         /**
 286          * @covers TextContent::copy
 287          */
 288         public function testCopy() {
 289                 $content = $this->newContent( 'hello world.' );
 290                 $copy = $content->copy();
 291
 292                 $this->assertTrue( $content->equals( $copy ), 'copy must be equal to original' );
 293                 $this->assertEquals( 'hello world.', $copy->getNativeData() );
 294         }
 295
 296         /**
 297          * @covers TextContent::getSize
 298          */
 299         public function testGetSize() {
 300                 $content = $this->newContent( 'hello world.' );
 301
 302                 $this->assertEquals( 12, $content->getSize() );
 303         }
 304
 305         /**
 306          * @covers TextContent::getNativeData
 307          */
 308         public function testGetNativeData() {
 309                 $content = $this->newContent( 'hello world.' );
 310
 311                 $this->assertEquals( 'hello world.', $content->getNativeData() );
 312         }
 313
 314         /**
 315          * @covers TextContent::getWikitextForTransclusion
 316          */
 317         public function testGetWikitextForTransclusion() {
 318                 $content = $this->newContent( 'hello world.' );
 319
 320                 $this->assertEquals( 'hello world.', $content->getWikitextForTransclusion() );
 321         }
 322
 323         /**
 324          * @covers TextContent::getModel
 325          */
 326         public function testGetModel() {
 327                 $content = $this->newContent( "hello world." );
 328
 329                 $this->assertEquals( CONTENT_MODEL_TEXT, $content->getModel() );
 330         }
 331
 332         /**
 333          * @covers TextContent::getContentHandler
 334          */
 335         public function testGetContentHandler() {
 336                 $content = $this->newContent( "hello world." );
 337
 338                 $this->assertEquals( CONTENT_MODEL_TEXT, $content->getContentHandler()->getModelID() );
 339         }
 340
 341         public static function dataIsEmpty() {
 342                 return [
 343                         [ '', true ],
 344                         [ '  ', false ],
 345                         [ '0', false ],
 346                         [ 'hallo welt.', false ],
 347                 ];
 348         }
 349
 350         /**
 351          * @dataProvider dataIsEmpty
 352          * @covers TextContent::isEmpty
 353          */
 354         public function testIsEmpty( $text, $empty ) {
 355                 $content = $this->newContent( $text );
 356
 357                 $this->assertEquals( $empty, $content->isEmpty() );
 358         }
 359
 360         public static function dataEquals() {
 361                 return [
 362                         [ new TextContent( "hallo" ), null, false ],
 363                         [ new TextContent( "hallo" ), new TextContent( "hallo" ), true ],
 364                         [ new TextContent( "hallo" ), new JavaScriptContent( "hallo" ), false ],
 365                         [ new TextContent( "hallo" ), new WikitextContent( "hallo" ), false ],
 366                         [ new TextContent( "hallo" ), new TextContent( "HALLO" ), false ],
 367                 ];
 368         }
 369
 370         /**
 371          * @dataProvider dataEquals
 372          * @covers TextContent::equals
 373          */
 374         public function testEquals( Content $a, Content $b = null, $equal = false ) {
 375                 $this->assertEquals( $equal, $a->equals( $b ) );
 376         }
 377
 378         public static function dataGetDeletionUpdates() {
 379                 return [
 380                         [ "TextContentTest_testGetSecondaryDataUpdates_1",
 381                                 CONTENT_MODEL_TEXT, "hello ''world''\n",
 382                                 []
 383                         ],
 384                         [ "TextContentTest_testGetSecondaryDataUpdates_2",
 385                                 CONTENT_MODEL_TEXT, "hello [[world test 21344]]\n",
 386                                 []
 387                         ],
 388                         // TODO: more...?
 389                 ];
 390         }
 391
 392         /**
 393          * @dataProvider dataGetDeletionUpdates
 394          * @covers TextContent::getDeletionUpdates
 395          */
 396         public function testDeletionUpdates( $title, $model, $text, $expectedStuff ) {
 397                 $ns = $this->getDefaultWikitextNS();
 398                 $title = Title::newFromText( $title, $ns );
 399
 400                 $content = ContentHandler::makeContent( $text, $title, $model );
 401
 402                 $page = WikiPage::factory( $title );
 403                 $page->doEditContent( $content, '' );
 404
 405                 $updates = $content->getDeletionUpdates( $page );
 406
 407                 // make updates accessible by class name
 408                 foreach ( $updates as $update ) {
 409                         $class = get_class( $update );
 410                         $updates[$class] = $update;
 411                 }
 412
 413                 if ( !$expectedStuff ) {
 414                         $this->assertTrue( true ); // make phpunit happy
 415                         return;
 416                 }
 417
 418                 foreach ( $expectedStuff as $class => $fieldValues ) {
 419                         $this->assertArrayHasKey( $class, $updates, "missing an update of type $class" );
 420
 421                         $update = $updates[$class];
 422
 423                         foreach ( $fieldValues as $field => $value ) {
 424                                 $v = $update->$field; # if the field doesn't exist, just crash and burn
 425                                 $this->assertEquals( $value, $v, "unexpected value for field $field in instance of $class" );
 426                         }
 427                 }
 428
 429                 $page->doDeleteArticle( '' );
 430         }
 431
 432         public static function provideConvert() {
 433                 return [
 434                         [ // #0
 435                                 'Hallo Welt',
 436                                 CONTENT_MODEL_WIKITEXT,
 437                                 'lossless',
 438                                 'Hallo Welt'
 439                         ],
 440                         [ // #1
 441                                 'Hallo Welt',
 442                                 CONTENT_MODEL_WIKITEXT,
 443                                 'lossless',
 444                                 'Hallo Welt'
 445                         ],
 446                         [ // #1
 447                                 'Hallo Welt',
 448                                 CONTENT_MODEL_CSS,
 449                                 'lossless',
 450                                 'Hallo Welt'
 451                         ],
 452                         [ // #1
 453                                 'Hallo Welt',
 454                                 CONTENT_MODEL_JAVASCRIPT,
 455                                 'lossless',
 456                                 'Hallo Welt'
 457                         ],
 458                 ];
 459         }
 460
 461         /**
 462          * @dataProvider provideConvert
 463          * @covers TextContent::convert
 464          */
 465         public function testConvert( $text, $model, $lossy, $expectedNative ) {
 466                 $content = $this->newContent( $text );
 467
 468                 $converted = $content->convert( $model, $lossy );
 469
 470                 if ( $expectedNative === false ) {
 471                         $this->assertFalse( $converted, "conversion to $model was expected to fail!" );
 472                 } else {
 473                         $this->assertInstanceOf( 'Content', $converted );
 474                         $this->assertEquals( $expectedNative, $converted->getNativeData() );
 475                 }
 476         }
 477 }