tests/phpunit/includes/content/WikitextContentHandlerTest.php

   1 <?php
   2
   3 /**
   4  * @group ContentHandler
   5  */
   6 class WikitextContentHandlerTest extends MediaWikiLangTestCase {
   7         /**
   8          * @var ContentHandler
   9          */
  10         private $handler;
  11
  12         protected function setUp() {
  13                 parent::setUp();
  14
  15                 $this->handler = ContentHandler::getForModelID( CONTENT_MODEL_WIKITEXT );
  16         }
  17
  18         /**
  19          * @covers WikitextContentHandler::serializeContent
  20          */
  21         public function testSerializeContent() {
  22                 $content = new WikitextContent( 'hello world' );
  23
  24                 $this->assertEquals( 'hello world', $this->handler->serializeContent( $content ) );
  25                 $this->assertEquals(
  26                         'hello world',
  27                         $this->handler->serializeContent( $content, CONTENT_FORMAT_WIKITEXT )
  28                 );
  29
  30                 try {
  31                         $this->handler->serializeContent( $content, 'dummy/foo' );
  32                         $this->fail( "serializeContent() should have failed on unknown format" );
  33                 } catch ( MWException $e ) {
  34                         // ok, as expected
  35                 }
  36         }
  37
  38         /**
  39          * @covers WikitextContentHandler::unserializeContent
  40          */
  41         public function testUnserializeContent() {
  42                 $content = $this->handler->unserializeContent( 'hello world' );
  43                 $this->assertEquals( 'hello world', $content->getNativeData() );
  44
  45                 $content = $this->handler->unserializeContent( 'hello world', CONTENT_FORMAT_WIKITEXT );
  46                 $this->assertEquals( 'hello world', $content->getNativeData() );
  47
  48                 try {
  49                         $this->handler->unserializeContent( 'hello world', 'dummy/foo' );
  50                         $this->fail( "unserializeContent() should have failed on unknown format" );
  51                 } catch ( MWException $e ) {
  52                         // ok, as expected
  53                 }
  54         }
  55
  56         /**
  57          * @covers WikitextContentHandler::makeEmptyContent
  58          */
  59         public function testMakeEmptyContent() {
  60                 $content = $this->handler->makeEmptyContent();
  61
  62                 $this->assertTrue( $content->isEmpty() );
  63                 $this->assertEquals( '', $content->getNativeData() );
  64         }
  65
  66         public static function dataIsSupportedFormat() {
  67                 return [
  68                         [ null, true ],
  69                         [ CONTENT_FORMAT_WIKITEXT, true ],
  70                         [ 99887766, false ],
  71                 ];
  72         }
  73
  74         /**
  75          * @dataProvider provideMakeRedirectContent
  76          * @param Title|string $title Title object or string for Title::newFromText()
  77          * @param string $expected Serialized form of the content object built
  78          * @covers WikitextContentHandler::makeRedirectContent
  79          */
  80         public function testMakeRedirectContent( $title, $expected ) {
  81                 global $wgContLang;
  82                 $wgContLang->resetNamespaces();
  83
  84                 MagicWord::clearCache();
  85
  86                 if ( is_string( $title ) ) {
  87                         $title = Title::newFromText( $title );
  88                 }
  89                 $content = $this->handler->makeRedirectContent( $title );
  90                 $this->assertEquals( $expected, $content->serialize() );
  91         }
  92
  93         public static function provideMakeRedirectContent() {
  94                 return [
  95                         [ 'Hello', '#REDIRECT [[Hello]]' ],
  96                         [ 'Template:Hello', '#REDIRECT [[Template:Hello]]' ],
  97                         [ 'Hello#section', '#REDIRECT [[Hello#section]]' ],
  98                         [ 'user:john_doe#section', '#REDIRECT [[User:John doe#section]]' ],
  99                         [ 'MEDIAWIKI:FOOBAR', '#REDIRECT [[MediaWiki:FOOBAR]]' ],
 100                         [ 'Category:Foo', '#REDIRECT [[:Category:Foo]]' ],
 101                         [ Title::makeTitle( NS_MAIN, 'en:Foo' ), '#REDIRECT [[en:Foo]]' ],
 102                         [ Title::makeTitle( NS_MAIN, 'Foo', '', 'en' ), '#REDIRECT [[:en:Foo]]' ],
 103                         [
 104                                 Title::makeTitle( NS_MAIN, 'Bar', 'fragment', 'google' ),
 105                                 '#REDIRECT [[google:Bar#fragment]]'
 106                         ],
 107                 ];
 108         }
 109
 110         /**
 111          * @dataProvider dataIsSupportedFormat
 112          * @covers WikitextContentHandler::isSupportedFormat
 113          */
 114         public function testIsSupportedFormat( $format, $supported ) {
 115                 $this->assertEquals( $supported, $this->handler->isSupportedFormat( $format ) );
 116         }
 117
 118         /**
 119          * @covers WikitextContentHandler::supportsDirectEditing
 120          */
 121         public function testSupportsDirectEditing() {
 122                 $handler = new WikiTextContentHandler();
 123                 $this->assertTrue( $handler->supportsDirectEditing(), 'direct editing is supported' );
 124         }
 125
 126         public static function dataMerge3() {
 127                 return [
 128                         [
 129                                 "first paragraph
 130
 131                                         second paragraph\n",
 132
 133                                 "FIRST paragraph
 134
 135                                         second paragraph\n",
 136
 137                                 "first paragraph
 138
 139                                         SECOND paragraph\n",
 140
 141                                 "FIRST paragraph
 142
 143                                         SECOND paragraph\n",
 144                         ],
 145
 146                         [ "first paragraph
 147                                         second paragraph\n",
 148
 149                                 "Bla bla\n",
 150
 151                                 "Blubberdibla\n",
 152
 153                                 false,
 154                         ],
 155                 ];
 156         }
 157
 158         /**
 159          * @dataProvider dataMerge3
 160          * @covers WikitextContentHandler::merge3
 161          */
 162         public function testMerge3( $old, $mine, $yours, $expected ) {
 163                 $this->markTestSkippedIfNoDiff3();
 164
 165                 // test merge
 166                 $oldContent = new WikitextContent( $old );
 167                 $myContent = new WikitextContent( $mine );
 168                 $yourContent = new WikitextContent( $yours );
 169
 170                 $merged = $this->handler->merge3( $oldContent, $myContent, $yourContent );
 171
 172                 $this->assertEquals( $expected, $merged ? $merged->getNativeData() : $merged );
 173         }
 174
 175         public static function dataGetAutosummary() {
 176                 return [
 177                         [
 178                                 'Hello there, world!',
 179                                 '#REDIRECT [[Foo]]',
 180                                 0,
 181                                 '/^Redirected page .*Foo/'
 182                         ],
 183
 184                         [
 185                                 null,
 186                                 'Hello world!',
 187                                 EDIT_NEW,
 188                                 '/^Created page .*Hello/'
 189                         ],
 190
 191                         [
 192                                 null,
 193                                 '',
 194                                 EDIT_NEW,
 195                                 '/^Created blank page$/'
 196                         ],
 197
 198                         [
 199                                 'Hello there, world!',
 200                                 '',
 201                                 0,
 202                                 '/^Blanked/'
 203                         ],
 204
 205                         [
 206                                 'Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy
 207                                 eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam
 208                                 voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet
 209                                 clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.',
 210                                 'Hello world!',
 211                                 0,
 212                                 '/^Replaced .*Hello/'
 213                         ],
 214
 215                         [
 216                                 'foo',
 217                                 'bar',
 218                                 0,
 219                                 '/^$/'
 220                         ],
 221                 ];
 222         }
 223
 224         /**
 225          * @dataProvider dataGetAutosummary
 226          * @covers WikitextContentHandler::getAutosummary
 227          */
 228         public function testGetAutosummary( $old, $new, $flags, $expected ) {
 229                 $oldContent = is_null( $old ) ? null : new WikitextContent( $old );
 230                 $newContent = is_null( $new ) ? null : new WikitextContent( $new );
 231
 232                 $summary = $this->handler->getAutosummary( $oldContent, $newContent, $flags );
 233
 234                 $this->assertTrue(
 235                         (bool)preg_match( $expected, $summary ),
 236                         "Autosummary didn't match expected pattern $expected: $summary"
 237                 );
 238         }
 239
 240         public static function dataGetChangeTag() {
 241                 return [
 242                         [
 243                                 null,
 244                                 '#REDIRECT [[Foo]]',
 245                                 0,
 246                                 'mw-new-redirect'
 247                         ],
 248
 249                         [
 250                                 'Lorem ipsum dolor',
 251                                 '#REDIRECT [[Foo]]',
 252                                 0,
 253                                 'mw-new-redirect'
 254                         ],
 255
 256                         [
 257                                 '#REDIRECT [[Foo]]',
 258                                 'Lorem ipsum dolor',
 259                                 0,
 260                                 'mw-removed-redirect'
 261                         ],
 262
 263                         [
 264                                 '#REDIRECT [[Foo]]',
 265                                 '#REDIRECT [[Bar]]',
 266                                 0,
 267                                 'mw-changed-redirect-target'
 268                         ],
 269
 270                         [
 271                                 null,
 272                                 'Lorem ipsum dolor',
 273                                 EDIT_NEW,
 274                                 null // mw-newpage is not defined as a tag
 275                         ],
 276
 277                         [
 278                                 null,
 279                                 '',
 280                                 EDIT_NEW,
 281                                 null // mw-newblank is not defined as a tag
 282                         ],
 283
 284                         [
 285                                 'Lorem ipsum dolor',
 286                                 '',
 287                                 0,
 288                                 'mw-blank'
 289                         ],
 290
 291                         [
 292                                 'Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy
 293                                 eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam
 294                                 voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet
 295                                 clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.',
 296                                 'Ipsum',
 297                                 0,
 298                                 'mw-replace'
 299                         ],
 300
 301                         [
 302                                 'Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy
 303                                 eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam
 304                                 voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet
 305                                 clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.',
 306                                 'Duis purus odio, rhoncus et finibus dapibus, facilisis ac urna. Pellentesque
 307                                 arcu, tristique nec tempus nec, suscipit vel arcu. Sed non dolor nec ligula
 308                                 congue tempor. Quisque pellentesque finibus orci a molestie. Nam maximus, purus
 309                                 euismod finibus mollis, dui ante malesuada felis, dignissim rutrum diam sapien.',
 310                                 0,
 311                                 null
 312                         ],
 313                 ];
 314         }
 315
 316         /**
 317          * @dataProvider dataGetChangeTag
 318          * @covers WikitextContentHandler::getChangeTag
 319          */
 320         public function testGetChangeTag( $old, $new, $flags, $expected ) {
 321                 $this->setMwGlobals( 'wgSoftwareTags', [
 322                         'mw-new-redirect' => true,
 323                         'mw-removed-redirect' => true,
 324                         'mw-changed-redirect-target' => true,
 325                         'mw-newpage' => true,
 326                         'mw-newblank' => true,
 327                         'mw-blank' => true,
 328                         'mw-replace' => true,
 329                 ] );
 330                 $oldContent = is_null( $old ) ? null : new WikitextContent( $old );
 331                 $newContent = is_null( $new ) ? null : new WikitextContent( $new );
 332
 333                 $tag = $this->handler->getChangeTag( $oldContent, $newContent, $flags );
 334
 335                 $this->assertSame( $expected, $tag );
 336         }
 337
 338         /**
 339          * @todo Text case requires database, should be done by a test class in the Database group
 340          */
 341         /*
 342         public function testGetAutoDeleteReason( Title $title, &$hasHistory ) {}
 343         */
 344
 345         /**
 346          * @todo Text case requires database, should be done by a test class in the Database group
 347          */
 348         /*
 349         public function testGetUndoContent( Revision $current, Revision $undo,
 350                 Revision $undoafter = null
 351         ) {
 352         }
 353         */
 354
 355         /**
 356          * @covers WikitextContentHandler::getDataForSearchIndex
 357          */
 358         public function testDataIndexFieldsFile() {
 359                 $mockEngine = $this->createMock( 'SearchEngine' );
 360                 $title = Title::newFromText( 'Somefile.jpg', NS_FILE );
 361                 $page = new WikiPage( $title );
 362
 363                 $fileHandler = $this->getMockBuilder( FileContentHandler::class )
 364                         ->disableOriginalConstructor()
 365                         ->setMethods( [ 'getDataForSearchIndex' ] )
 366                         ->getMock();
 367
 368                 $handler = $this->getMockBuilder( WikitextContentHandler::class )
 369                         ->disableOriginalConstructor()
 370                         ->setMethods( [ 'getFileHandler' ] )
 371                         ->getMock();
 372
 373                 $handler->method( 'getFileHandler' )->will( $this->returnValue( $fileHandler ) );
 374                 $fileHandler->expects( $this->once() )
 375                         ->method( 'getDataForSearchIndex' )
 376                         ->will( $this->returnValue( [ 'file_text' => 'This is file content' ] ) );
 377
 378                 $data = $handler->getDataForSearchIndex( $page, new ParserOutput(), $mockEngine );
 379                 $this->assertArrayHasKey( 'file_text', $data );
 380                 $this->assertEquals( 'This is file content', $data['file_text'] );
 381         }
 382 }