ContentHandlerTest.php

Go to the documentation of this file.

<?php
use MediaWiki\MediaWikiServices;
use Wikimedia\TestingAccessWrapper;
 
class ContentHandlerTest extends MediaWikiTestCase {
 
    protected function setUp() {
        parent::setUp();
 
        $this->setMwGlobals( [
            'wgExtraNamespaces' => [
                12312 => 'Dummy',
                12313 => 'Dummy_talk',
            ],
            // The below tests assume that namespaces not mentioned here (Help, User, MediaWiki, ..)
            // default to CONTENT_MODEL_WIKITEXT.
            'wgNamespaceContentModels' => [
                12312 => 'testing',
            ],
            'wgContentHandlers' => [
                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' => function ( $modelId ) {
                    return new DummyContentHandlerForTesting( $modelId );
                }
            ],
        ] );
 
        // Reset LinkCache
        MediaWikiServices::getInstance()->resetServiceForTesting( 'LinkCache' );
    }
 
    protected function tearDown() {
        // Reset LinkCache
        MediaWikiServices::getInstance()->resetServiceForTesting( 'LinkCache' );
 
        parent::tearDown();
    }
 
    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 ],
        ];
    }
 
    public function testGetDefaultModelFor( $title, $expectedModelId ) {
        $title = Title::newFromText( $title );
        $this->assertEquals( $expectedModelId, ContentHandler::getDefaultModelFor( $title ) );
    }
 
    public function testGetForTitle( $title, $expectedContentModel ) {
        $title = Title::newFromText( $title );
        MediaWikiServices::getInstance()->getLinkCache()->addBadLinkObj( $title );
        $handler = ContentHandler::getForTitle( $title );
        $this->assertEquals( $expectedContentModel, $handler->getModelID() );
    }
 
    public static function dataGetLocalizedName() {
        return [
            [ null, null ],
            [ "xyzzy", null ],
 
            // XXX: depends on content language
            [ CONTENT_MODEL_JAVASCRIPT, '/javascript/i' ],
        ];
    }
 
    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 ],
 
            [ CONTENT_MODEL_JAVASCRIPT, 'javascript' ],
        ];
    }
 
    public function testGetPageLanguage( $title, $expected ) {
        if ( is_string( $title ) ) {
            $title = Title::newFromText( $title );
            MediaWikiServices::getInstance()->getLinkCache()->addBadLinkObj( $title );
        }
 
        $expected = wfGetLangObj( $expected );
 
        $handler = ContentHandler::getForTitle( $title );
        $lang = $handler->getPageLanguage( $title );
 
        $this->assertEquals( $expected->getCode(), $lang->getCode() );
    }
 
    public static function dataGetContentText_Null() {
        return [
            [ 'fail' ],
            [ 'serialize' ],
            [ 'ignore' ],
        ];
    }
 
    public function testGetContentText_Null( $contentHandlerTextFallback ) {
        $this->setMwGlobals( 'wgContentHandlerTextFallback', $contentHandlerTextFallback );
 
        $content = null;
 
        $text = ContentHandler::getContentText( $content );
        $this->assertEquals( '', $text );
    }
 
    public static function dataGetContentText_TextContent() {
        return [
            [ 'fail' ],
            [ 'serialize' ],
            [ 'ignore' ],
        ];
    }
 
    public function testGetContentText_TextContent( $contentHandlerTextFallback ) {
        $this->setMwGlobals( 'wgContentHandlerTextFallback', $contentHandlerTextFallback );
 
        $content = new WikitextContent( "hello world" );
 
        $text = ContentHandler::getContentText( $content );
        $this->assertEquals( $content->getNativeData(), $text );
    }
 
    public function testGetContentText_NonTextContent_fail() {
        $this->setMwGlobals( 'wgContentHandlerTextFallback', 'fail' );
 
        $content = new DummyContentForTesting( "hello world" );
 
        ContentHandler::getContentText( $content );
    }
 
    public function testGetContentText_NonTextContent_serialize() {
        $this->setMwGlobals( 'wgContentHandlerTextFallback', 'serialize' );
 
        $content = new DummyContentForTesting( "hello world" );
 
        $text = ContentHandler::getContentText( $content );
        $this->assertEquals( $content->serialize(), $text );
    }
 
    public function testGetContentText_NonTextContent_ignore() {
        $this->setMwGlobals( 'wgContentHandlerTextFallback', 'ignore' );
 
        $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, 'hallo', false ],
            [ 'hallo', 'MediaWiki:Test.js', null, null, CONTENT_MODEL_JAVASCRIPT, 'hallo', false ],
            [ serialize( 'hallo' ), 'Dummy:Test', null, null, "testing", 'hallo', false ],
 
            [
                'hallo',
                'Help:Test',
                null,
                CONTENT_FORMAT_WIKITEXT,
                CONTENT_MODEL_WIKITEXT,
                'hallo',
                false
            ],
            [
                'hallo',
                'MediaWiki:Test.js',
                null,
                CONTENT_FORMAT_JAVASCRIPT,
                CONTENT_MODEL_JAVASCRIPT,
                'hallo',
                false
            ],
            [ serialize( 'hallo' ), 'Dummy:Test', null, "testing", "testing", 'hallo', false ],
 
            [ 'hallo', 'Help:Test', CONTENT_MODEL_CSS, null, CONTENT_MODEL_CSS, 'hallo', false ],
            [
                'hallo',
                'MediaWiki:Test.js',
                CONTENT_MODEL_CSS,
                null,
                CONTENT_MODEL_CSS,
                'hallo',
                false
            ],
            [
                serialize( 'hallo' ),
                'Dummy:Test',
                CONTENT_MODEL_CSS,
                null,
                CONTENT_MODEL_CSS,
                serialize( 'hallo' ),
                false
            ],
 
            [ 'hallo', 'Help:Test', CONTENT_MODEL_WIKITEXT, "testing", null, null, true ],
            [ 'hallo', 'MediaWiki:Test.js', CONTENT_MODEL_CSS, "testing", null, null, true ],
            [ 'hallo', 'Dummy:Test', CONTENT_MODEL_JAVASCRIPT, "testing", null, null, true ],
        ];
    }
 
    public function testMakeContent( $data, $title, $modelId, $format,
        $expectedModelId, $expectedNativeData, $shouldFail
    ) {
        $title = Title::newFromText( $title );
        MediaWikiServices::getInstance()->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( $expectedNativeData, $content->getNativeData(), 'bads native 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 );
            }
        }
    }
 
    public function testGetAutosummary() {
        $this->setContentLang( 'en' );
 
        $content = new DummyContentHandlerForTesting( CONTENT_MODEL_WIKITEXT );
        $title = Title::newFromText( '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( $autoSummary,
            wfMessage( 'autosumm-newblank' )->inContentLanguage()->text() );
        // now check, what we become with another bitmask
        $autoSummary = $content->getAutosummary( null, $newContent, 92 );
        $this->assertEquals( $autoSummary, '' );
    }
 
    public function testGetChangeTag() {
        $this->setMwGlobals( 'wgSoftwareTags', [ '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( $tag, 'mw-contentmodelchange' );
    }
 
    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 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 ],
        ];
    }
 
    public function testGetModelForID( $modelId, $handlerClass ) {
        $handler = ContentHandler::getForModelID( $modelId );
 
        $this->assertInstanceOf( $handlerClass, $handler );
    }
 
    public function testGetFieldsForSearchIndex() {
        $searchEngine = $this->newSearchEngine();
 
        $handler = ContentHandler::getForModelID( CONTENT_MODEL_WIKITEXT );
 
        $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->getMockBuilder( SearchEngine::class )
            ->getMock();
 
        $searchEngine->expects( $this->any() )
            ->method( 'makeSearchFieldMapping' )
            ->will( $this->returnCallback( function ( $name, $type ) {
                    return new DummySearchIndexFieldDefinition( $name, $type );
            } ) );
 
        return $searchEngine;
    }
 
    public function testDataIndexFields() {
        $mockEngine = $this->createMock( SearchEngine::class );
        $title = Title::newFromText( 'Not_Main_Page', NS_MAIN );
        $page = new WikiPage( $title );
 
        $this->setTemporaryHook( 'SearchDataForIndex',
            function (
                &$fields,
                ContentHandler $handler,
                WikiPage $page,
                ParserOutput $output,
                SearchEngine $engine
            ) {
                $fields['testDataField'] = 'test content';
            } );
 
        $output = $page->getContent()->getParserOutput( $title );
        $data = $page->getContentHandler()->getDataForSearchIndex( $page, $output, $mockEngine );
        $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() {
        $title = Title::newFromText( 'Smithee', NS_MAIN );
        $page = new WikiPage( $title );
 
        $out = $page->getContentHandler()->getParserOutputForIndexing( $page );
        $this->assertInstanceOf( ParserOutput::class, $out );
        $this->assertContains( 'one who smiths', $out->getRawText() );
    }
 
    public function testGetContentModelsHook() {
        $this->setTemporaryHook( 'GetContentModels', function ( &$models ) {
            $models[] = 'Ferrari';
        } );
        $this->assertContains( 'Ferrari', ContentHandler::getContentModels() );
    }
 
    public function testGetSlotDiffRenderer_default() {
        $this->mergeMwGlobalArrayValue( 'wgHooks', [
            'GetSlotDiffRenderer' => [],
        ] );
 
        // test default renderer
        $contentHandler = new WikitextContentHandler( CONTENT_MODEL_WIKITEXT );
        $slotDiffRenderer = $contentHandler->getSlotDiffRenderer( RequestContext::getMain() );
        $this->assertInstanceOf( TextSlotDiffRenderer::class, $slotDiffRenderer );
    }
 
    public function testGetSlotDiffRenderer_bc() {
        $this->mergeMwGlobalArrayValue( 'wgHooks', [
            'GetSlotDiffRenderer' => [],
        ] );
 
        // test B/C renderer
        $customDifferenceEngine = $this->getMockBuilder( DifferenceEngine::class )
            ->disableOriginalConstructor()
            ->getMock();
        // hack to track object identity across cloning
        $customDifferenceEngine->objectId = 12345;
        $customContentHandler = $this->getMockBuilder( ContentHandler::class )
            ->setConstructorArgs( [ 'foo', [] ] )
            ->setMethods( [ 'createDifferenceEngine' ] )
            ->getMockForAbstractClass();
        $customContentHandler->expects( $this->any() )
            ->method( 'createDifferenceEngine' )
            ->willReturn( $customDifferenceEngine );
        $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->getMockBuilder( DifferenceEngine::class )
            ->disableOriginalConstructor()
            ->getMock();
        $customSlotDiffRenderer = $this->getMockBuilder( SlotDiffRenderer::class )
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $customContentHandler2 = $this->getMockBuilder( ContentHandler::class )
            ->setConstructorArgs( [ 'bar', [] ] )
            ->setMethods( [ 'createDifferenceEngine', 'getSlotDiffRendererInternal' ] )
            ->getMockForAbstractClass();
        $customContentHandler2->expects( $this->any() )
            ->method( 'createDifferenceEngine' )
            ->willReturn( $customDifferenceEngine );
        $customContentHandler2->expects( $this->any() )
            ->method( 'getSlotDiffRendererInternal' )
            ->willReturn( $customSlotDiffRenderer );
        $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->getMockBuilder( DifferenceEngine::class )
            ->disableOriginalConstructor()
            ->getMock();
        $customContentHandler = $this->getMockBuilder( ContentHandler::class )
            ->setConstructorArgs( [ 'foo', [] ] )
            ->setMethods( [ 'createDifferenceEngine' ] )
            ->getMockForAbstractClass();
        $customContentHandler->expects( $this->any() )
            ->method( 'createDifferenceEngine' )
            ->willReturn( $customDifferenceEngine );
        $customSlotDiffRenderer = $this->getMockBuilder( SlotDiffRenderer::class )
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $customContentHandler2 = $this->getMockBuilder( ContentHandler::class )
            ->setConstructorArgs( [ 'bar', [] ] )
            ->setMethods( [ 'createDifferenceEngine', 'getSlotDiffRendererInternal' ] )
            ->getMockForAbstractClass();
        $customContentHandler2->expects( $this->any() )
            ->method( 'createDifferenceEngine' )
            ->willReturn( $customDifferenceEngine );
        $customContentHandler2->expects( $this->any() )
            ->method( 'getSlotDiffRendererInternal' )
            ->willReturn( $customSlotDiffRenderer );
        $customSlotDiffRenderer2 = $this->getMockBuilder( SlotDiffRenderer::class )
            ->disableOriginalConstructor()
            ->getMockForAbstractClass();
        $this->setTemporaryHook( 'GetSlotDiffRenderer',
            function ( $handler, &$slotDiffRenderer ) use ( $customSlotDiffRenderer2 ) {
                $slotDiffRenderer = $customSlotDiffRenderer2;
            } );
 
        $slotDiffRenderer = $customContentHandler->getSlotDiffRenderer( RequestContext::getMain() );
        $this->assertSame( $customSlotDiffRenderer2, $slotDiffRenderer );
        $slotDiffRenderer = $customContentHandler2->getSlotDiffRenderer( RequestContext::getMain() );
        $this->assertSame( $customSlotDiffRenderer2, $slotDiffRenderer );
    }
 
}