ContentHandlerTest.php

Go to the documentation of this file.

<?php
 
class ContentHandlerTest extends MediaWikiTestCase {
 
    protected function setUp() {
        global $wgContLang;
        parent::setUp();
 
        $this->setMwGlobals( array(
            'wgExtraNamespaces' => array(
                12312 => 'Dummy',
                12313 => 'Dummy_talk',
            ),
            // The below tests assume that namespaces not mentioned here (Help, User, MediaWiki, ..)
            // default to CONTENT_MODEL_WIKITEXT.
            'wgNamespaceContentModels' => array(
                12312 => 'testing',
            ),
            'wgContentHandlers' => array(
                CONTENT_MODEL_WIKITEXT => 'WikitextContentHandler',
                CONTENT_MODEL_JAVASCRIPT => 'JavaScriptContentHandler',
                CONTENT_MODEL_CSS => 'CssContentHandler',
                CONTENT_MODEL_TEXT => 'TextContentHandler',
                'testing' => 'DummyContentHandlerForTesting',
            ),
        ) );
 
        // Reset namespace cache
        MWNamespace::getCanonicalNamespaces( true );
        $wgContLang->resetNamespaces();
    }
 
    protected function tearDown() {
        global $wgContLang;
 
        // Reset namespace cache
        MWNamespace::getCanonicalNamespaces( true );
        $wgContLang->resetNamespaces();
 
        parent::tearDown();
    }
 
    public static function dataGetDefaultModelFor() {
        return array(
            array( 'Help:Foo', CONTENT_MODEL_WIKITEXT ),
            array( 'Help:Foo.js', CONTENT_MODEL_WIKITEXT ),
            array( 'Help:Foo/bar.js', CONTENT_MODEL_WIKITEXT ),
            array( 'User:Foo', CONTENT_MODEL_WIKITEXT ),
            array( 'User:Foo.js', CONTENT_MODEL_WIKITEXT ),
            array( 'User:Foo/bar.js', CONTENT_MODEL_JAVASCRIPT ),
            array( 'User:Foo/bar.css', CONTENT_MODEL_CSS ),
            array( 'User talk:Foo/bar.css', CONTENT_MODEL_WIKITEXT ),
            array( 'User:Foo/bar.js.xxx', CONTENT_MODEL_WIKITEXT ),
            array( 'User:Foo/bar.xxx', CONTENT_MODEL_WIKITEXT ),
            array( 'MediaWiki:Foo.js', CONTENT_MODEL_JAVASCRIPT ),
            array( 'MediaWiki:Foo.css', CONTENT_MODEL_CSS ),
            array( 'MediaWiki:Foo.JS', CONTENT_MODEL_WIKITEXT ),
            array( 'MediaWiki:Foo.CSS', CONTENT_MODEL_WIKITEXT ),
            array( 'MediaWiki:Foo.css.xxx', 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 );
        $handler = ContentHandler::getForTitle( $title );
        $this->assertEquals( $expectedContentModel, $handler->getModelID() );
    }
 
    public static function dataGetLocalizedName() {
        return array(
            array( null, null ),
            array( "xyzzy", null ),
 
            // XXX: depends on content language
            array( 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 array(
            array( "Main", $wgLanguageCode ),
            array( "Dummy:Foo", $wgLanguageCode ),
            array( "MediaWiki:common.js", 'en' ),
            array( "User:Foo/common.js", 'en' ),
            array( "MediaWiki:common.css", 'en' ),
            array( "User:Foo/common.css", 'en' ),
            array( "User:Foo", $wgLanguageCode ),
 
            array( CONTENT_MODEL_JAVASCRIPT, 'javascript' ),
        );
    }
 
    public function testGetPageLanguage( $title, $expected ) {
        if ( is_string( $title ) ) {
            $title = Title::newFromText( $title );
        }
 
        $expected = wfGetLangObj( $expected );
 
        $handler = ContentHandler::getForTitle( $title );
        $lang = $handler->getPageLanguage( $title );
 
        $this->assertEquals( $expected->getCode(), $lang->getCode() );
    }
 
    public static function dataGetContentText_Null() {
        return array(
            array( 'fail' ),
            array( 'serialize' ),
            array( '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 array(
            array( 'fail' ),
            array( 'serialize' ),
            array( '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 makeContent( $text, Title $title, $modelId = null, $format = null ) {}
    */
 
    public static function dataMakeContent() {
        return array(
            array( 'hallo', 'Help:Test', null, null, CONTENT_MODEL_WIKITEXT, 'hallo', false ),
            array( 'hallo', 'MediaWiki:Test.js', null, null, CONTENT_MODEL_JAVASCRIPT, 'hallo', false ),
            array( serialize( 'hallo' ), 'Dummy:Test', null, null, "testing", 'hallo', false ),
 
            array( 'hallo', 'Help:Test', null, CONTENT_FORMAT_WIKITEXT, CONTENT_MODEL_WIKITEXT, 'hallo', false ),
            array( 'hallo', 'MediaWiki:Test.js', null, CONTENT_FORMAT_JAVASCRIPT, CONTENT_MODEL_JAVASCRIPT, 'hallo', false ),
            array( serialize( 'hallo' ), 'Dummy:Test', null, "testing", "testing", 'hallo', false ),
 
            array( 'hallo', 'Help:Test', CONTENT_MODEL_CSS, null, CONTENT_MODEL_CSS, 'hallo', false ),
            array( 'hallo', 'MediaWiki:Test.js', CONTENT_MODEL_CSS, null, CONTENT_MODEL_CSS, 'hallo', false ),
            array( serialize( 'hallo' ), 'Dummy:Test', CONTENT_MODEL_CSS, null, CONTENT_MODEL_CSS, serialize( 'hallo' ), false ),
 
            array( 'hallo', 'Help:Test', CONTENT_MODEL_WIKITEXT, "testing", null, null, true ),
            array( 'hallo', 'MediaWiki:Test.js', CONTENT_MODEL_CSS, "testing", null, null, true ),
            array( 'hallo', 'Dummy:Test', CONTENT_MODEL_JAVASCRIPT, "testing", null, null, true ),
        );
    }
 
    public function testMakeContent( $data, $title, $modelId, $format, $expectedModelId, $expectedNativeData, $shouldFail ) {
        $title = Title::newFromText( $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 testSupportsSections() {
        $this->markTestIncomplete( "not yet implemented" );
    }
    */
 
    public function testRunLegacyHooks() {
        Hooks::register( 'testRunLegacyHooks', __CLASS__ . '::dummyHookHandler' );
 
        $content = new WikitextContent( 'test text' );
        $ok = ContentHandler::runLegacyHooks( 'testRunLegacyHooks', array( 'foo', &$content, 'bar' ), false );
 
        $this->assertTrue( $ok, "runLegacyHooks should have returned true" );
        $this->assertEquals( "TEST TEXT", $content->getNativeData() );
    }
 
    public static function dummyHookHandler( $foo, &$text, $bar ) {
        if ( $text === null || $text === false ) {
            return false;
        }
 
        $text = strtoupper( $text );
 
        return true;
    }
}
 
class DummyContentHandlerForTesting extends ContentHandler {
 
    public function __construct( $dataModel ) {
        parent::__construct( $dataModel, array( "testing" ) );
    }
 
    public function serializeContent( Content $content, $format = null ) {
        return $content->serialize();
    }
 
    public function unserializeContent( $blob, $format = null ) {
        $d = unserialize( $blob );
 
        return new DummyContentForTesting( $d );
    }
 
    public function makeEmptyContent() {
        return new DummyContentForTesting( '' );
    }
}
 
class DummyContentForTesting extends AbstractContent {
 
    public function __construct( $data ) {
        parent::__construct( "testing" );
 
        $this->data = $data;
    }
 
    public function serialize( $format = null ) {
        return serialize( $this->data );
    }
 
    public function getTextForSearchIndex() {
        return '';
    }
 
    public function getWikitextForTransclusion() {
        return false;
    }
 
    public function getTextForSummary( $maxlength = 250 ) {
        return '';
    }
 
    public function getNativeData() {
        return $this->data;
    }
 
    public function getSize() {
        return strlen( $this->data );
    }
 
    public function copy() {
        return $this;
    }
 
    public function isCountable( $hasLinks = null ) {
        return false;
    }
 
    public function getParserOutput( Title $title, $revId = null, ParserOptions $options = null, $generateHtml = true ) {
        return new ParserOutput( $this->getNativeData() );
    }
}