MediaWikiTestCase.php

Go to the documentation of this file.

<?php

abstract class MediaWikiTestCase extends PHPUnit_Framework_TestCase {
    public $suite;
    public $regex = '';
    public $runDisabled = false;

    private $called = array();

    public static $users;

    protected $db;
    protected $tablesUsed = array(); // tables with data

    private static $useTemporaryTables = true;
    private static $reuseDB = false;
    private static $dbSetup = false;
    private static $oldTablePrefix = false;

    private $tmpfiles = array();

    private $mwGlobals = array();

    const DB_PREFIX = 'unittest_';
    const ORA_DB_PREFIX = 'ut_';

    protected $supportedDBs = array(
        'mysql',
        'sqlite',
        'postgres',
        'oracle'
    );

    function __construct( $name = null, array $data = array(), $dataName = '' ) {
        parent::__construct( $name, $data, $dataName );

        $this->backupGlobals = false;
        $this->backupStaticAttributes = false;
    }

    function run( PHPUnit_Framework_TestResult $result = null ) {
        /* Some functions require some kind of caching, and will end up using the db,
         * which we can't allow, as that would open a new connection for mysql.
         * Replace with a HashBag. They would not be going to persist anyway.
         */
        ObjectCache::$instances[CACHE_DB] = new HashBagOStuff;

        $needsResetDB = false;
        $logName = get_class( $this ) . '::' . $this->getName( false );

        if ( $this->needsDB() ) {
            // set up a DB connection for this test to use

            self::$useTemporaryTables = !$this->getCliArg( 'use-normal-tables' );
            self::$reuseDB = $this->getCliArg( 'reuse-db' );

            $this->db = wfGetDB( DB_MASTER );

            $this->checkDbIsSupported();

            if ( !self::$dbSetup ) {
                wfProfileIn( $logName . ' (clone-db)' );

                // switch to a temporary clone of the database
                self::setupTestDB( $this->db, $this->dbPrefix() );

                if ( ( $this->db->getType() == 'oracle' || !self::$useTemporaryTables ) && self::$reuseDB ) {
                    $this->resetDB();
                }

                wfProfileOut( $logName . ' (clone-db)' );
            }

            wfProfileIn( $logName . ' (prepare-db)' );
            $this->addCoreDBData();
            $this->addDBData();
            wfProfileOut( $logName . ' (prepare-db)' );

            $needsResetDB = true;
        }

        wfProfileIn( $logName );
        parent::run( $result );
        wfProfileOut( $logName );

        if ( $needsResetDB ) {
            wfProfileIn( $logName . ' (reset-db)' );
            $this->resetDB();
            wfProfileOut( $logName . ' (reset-db)' );
        }
    }

    function usesTemporaryTables() {
        return self::$useTemporaryTables;
    }

    protected function getNewTempFile() {
        $fname = tempnam( wfTempDir(), 'MW_PHPUnit_' . get_class( $this ) . '_' );
        $this->tmpfiles[] = $fname;

        return $fname;
    }

    protected function getNewTempDirectory() {
        // Starting of with a temporary /file/.
        $fname = $this->getNewTempFile();

        // Converting the temporary /file/ to a /directory/
        //
        // The following is not atomic, but at least we now have a single place,
        // where temporary directory creation is bundled and can be improved
        unlink( $fname );
        $this->assertTrue( wfMkdirParents( $fname ) );

        return $fname;
    }

    protected function setUp() {
        wfProfileIn( __METHOD__ );
        parent::setUp();
        $this->called['setUp'] = 1;

        /*
        // @todo global variables to restore for *every* test
        array(
            'wgLang',
            'wgContLang',
            'wgLanguageCode',
            'wgUser',
            'wgTitle',
        );
        */

        // Cleaning up temporary files
        foreach ( $this->tmpfiles as $fname ) {
            if ( is_file( $fname ) || ( is_link( $fname ) ) ) {
                unlink( $fname );
            } elseif ( is_dir( $fname ) ) {
                wfRecursiveRemoveDir( $fname );
            }
        }

        if ( $this->needsDB() && $this->db ) {
            // Clean up open transactions
            while ( $this->db->trxLevel() > 0 ) {
                $this->db->rollback();
            }

            // don't ignore DB errors
            $this->db->ignoreErrors( false );
        }

        wfProfileOut( __METHOD__ );
    }

    protected function tearDown() {
        wfProfileIn( __METHOD__ );

        // Cleaning up temporary files
        foreach ( $this->tmpfiles as $fname ) {
            if ( is_file( $fname ) || ( is_link( $fname ) ) ) {
                unlink( $fname );
            } elseif ( is_dir( $fname ) ) {
                wfRecursiveRemoveDir( $fname );
            }
        }

        if ( $this->needsDB() && $this->db ) {
            // Clean up open transactions
            while ( $this->db->trxLevel() > 0 ) {
                $this->db->rollback();
            }

            // don't ignore DB errors
            $this->db->ignoreErrors( false );
        }

        // Restore mw globals
        foreach ( $this->mwGlobals as $key => $value ) {
            $GLOBALS[$key] = $value;
        }
        $this->mwGlobals = array();

        parent::tearDown();
        wfProfileOut( __METHOD__ );
    }

    final public function testMediaWikiTestCaseParentSetupCalled() {
        $this->assertArrayHasKey( 'setUp', $this->called,
            get_called_class() . "::setUp() must call parent::setUp()"
        );
    }

    protected function setMwGlobals( $pairs, $value = null ) {

        // Normalize (string, value) to an array
        if ( is_string( $pairs ) ) {
            $pairs = array( $pairs => $value );
        }

        foreach ( $pairs as $key => $value ) {
            // NOTE: make sure we only save the global once or a second call to
            // setMwGlobals() on the same global would override the original
            // value.
            if ( !array_key_exists( $key, $this->mwGlobals ) ) {
                $this->mwGlobals[$key] = $GLOBALS[$key];
            }

            // Override the global
            $GLOBALS[$key] = $value;
        }
    }

    protected function mergeMwGlobalArrayValue( $name, $values ) {
        if ( !isset( $GLOBALS[$name] ) ) {
            $merged = $values;
        } else {
            if ( !is_array( $GLOBALS[$name] ) ) {
                throw new MWException( "MW global $name is not an array." );
            }

            // NOTE: do not use array_merge, it screws up for numeric keys.
            $merged = $GLOBALS[$name];
            foreach ( $values as $k => $v ) {
                $merged[$k] = $v;
            }
        }

        $this->setMwGlobals( $name, $merged );
    }

    function dbPrefix() {
        return $this->db->getType() == 'oracle' ? self::ORA_DB_PREFIX : self::DB_PREFIX;
    }

    function needsDB() {
        # if the test says it uses database tables, it needs the database
        if ( $this->tablesUsed ) {
            return true;
        }

        # if the test says it belongs to the Database group, it needs the database
        $rc = new ReflectionClass( $this );
        if ( preg_match( '/@group +Database/im', $rc->getDocComment() ) ) {
            return true;
        }

        return false;
    }

    function addDBData() {
    }

    private function addCoreDBData() {
        # disabled for performance
        #$this->tablesUsed[] = 'page';
        #$this->tablesUsed[] = 'revision';

        if ( $this->db->getType() == 'oracle' ) {

            # Insert 0 user to prevent FK violations
            # Anonymous user
            $this->db->insert( 'user', array(
                'user_id' => 0,
                'user_name' => 'Anonymous' ), __METHOD__, array( 'IGNORE' ) );

            # Insert 0 page to prevent FK violations
            # Blank page
            $this->db->insert( 'page', array(
                'page_id' => 0,
                'page_namespace' => 0,
                'page_title' => ' ',
                'page_restrictions' => null,
                'page_counter' => 0,
                'page_is_redirect' => 0,
                'page_is_new' => 0,
                'page_random' => 0,
                'page_touched' => $this->db->timestamp(),
                'page_latest' => 0,
                'page_len' => 0 ), __METHOD__, array( 'IGNORE' ) );
        }

        User::resetIdByNameCache();

        //Make sysop user
        $user = User::newFromName( 'UTSysop' );

        if ( $user->idForName() == 0 ) {
            $user->addToDatabase();
            $user->setPassword( 'UTSysopPassword' );

            $user->addGroup( 'sysop' );
            $user->addGroup( 'bureaucrat' );
            $user->saveSettings();
        }

        //Make 1 page with 1 revision
        $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
        if ( !$page->getId() == 0 ) {
            $page->doEditContent(
                new WikitextContent( 'UTContent' ),
                'UTPageSummary',
                EDIT_NEW,
                false,
                User::newFromName( 'UTSysop' ) );
        }
    }

    public static function teardownTestDB() {
        if ( !self::$dbSetup ) {
            return;
        }

        CloneDatabase::changePrefix( self::$oldTablePrefix );

        self::$oldTablePrefix = false;
        self::$dbSetup = false;
    }

    public static function setupTestDB( DatabaseBase $db, $prefix ) {
        global $wgDBprefix;
        if ( $wgDBprefix === $prefix ) {
            throw new MWException( 'Cannot run unit tests, the database prefix is already "' . $prefix . '"' );
        }

        if ( self::$dbSetup ) {
            return;
        }

        $tablesCloned = self::listTables( $db );
        $dbClone = new CloneDatabase( $db, $tablesCloned, $prefix );
        $dbClone->useTemporaryTables( self::$useTemporaryTables );

        self::$dbSetup = true;
        self::$oldTablePrefix = $wgDBprefix;

        if ( ( $db->getType() == 'oracle' || !self::$useTemporaryTables ) && self::$reuseDB ) {
            CloneDatabase::changePrefix( $prefix );

            return;
        } else {
            $dbClone->cloneTableStructure();
        }

        if ( $db->getType() == 'oracle' ) {
            $db->query( 'BEGIN FILL_WIKI_INFO; END;' );
        }
    }

    private function resetDB() {
        if ( $this->db ) {
            if ( $this->db->getType() == 'oracle' ) {
                if ( self::$useTemporaryTables ) {
                    wfGetLB()->closeAll();
                    $this->db = wfGetDB( DB_MASTER );
                } else {
                    foreach ( $this->tablesUsed as $tbl ) {
                        if ( $tbl == 'interwiki' ) {
                            continue;
                        }
                        $this->db->query( 'TRUNCATE TABLE ' . $this->db->tableName( $tbl ), __METHOD__ );
                    }
                }
            } else {
                foreach ( $this->tablesUsed as $tbl ) {
                    if ( $tbl == 'interwiki' || $tbl == 'user' ) {
                        continue;
                    }
                    $this->db->delete( $tbl, '*', __METHOD__ );
                }
            }
        }
    }

    function __call( $func, $args ) {
        static $compatibility = array(
            'assertInternalType' => 'assertType',
            'assertNotInternalType' => 'assertNotType',
            'assertInstanceOf' => 'assertType',
            'assertEmpty' => 'assertEmpty2',
        );

        if ( method_exists( $this->suite, $func ) ) {
            return call_user_func_array( array( $this->suite, $func ), $args );
        } elseif ( isset( $compatibility[$func] ) ) {
            return call_user_func_array( array( $this, $compatibility[$func] ), $args );
        } else {
            throw new MWException( "Called non-existant $func method on "
                . get_class( $this ) );
        }
    }

    private function assertEmpty2( $value, $msg ) {
        return $this->assertTrue( $value == '', $msg );
    }

    private static function unprefixTable( $tableName ) {
        global $wgDBprefix;

        return substr( $tableName, strlen( $wgDBprefix ) );
    }

    private static function isNotUnittest( $table ) {
        return strpos( $table, 'unittest_' ) !== 0;
    }

    public static function listTables( $db ) {
        global $wgDBprefix;

        $tables = $db->listTables( $wgDBprefix, __METHOD__ );

        if ( $db->getType() === 'mysql' ) {
            # bug 43571: cannot clone VIEWs under MySQL
            $views = $db->listViews( $wgDBprefix, __METHOD__ );
            $tables = array_diff( $tables, $views );
        }
        $tables = array_map( array( __CLASS__, 'unprefixTable' ), $tables );

        // Don't duplicate test tables from the previous fataled run
        $tables = array_filter( $tables, array( __CLASS__, 'isNotUnittest' ) );

        if ( $db->getType() == 'sqlite' ) {
            $tables = array_flip( $tables );
            // these are subtables of searchindex and don't need to be duped/dropped separately
            unset( $tables['searchindex_content'] );
            unset( $tables['searchindex_segdir'] );
            unset( $tables['searchindex_segments'] );
            $tables = array_flip( $tables );
        }

        return $tables;
    }

    protected function checkDbIsSupported() {
        if ( !in_array( $this->db->getType(), $this->supportedDBs ) ) {
            throw new MWException( $this->db->getType() . " is not currently supported for unit testing." );
        }
    }

    public function getCliArg( $offset ) {

        if ( isset( MediaWikiPHPUnitCommand::$additionalOptions[$offset] ) ) {
            return MediaWikiPHPUnitCommand::$additionalOptions[$offset];
        }
    }

    public function setCliArg( $offset, $value ) {

        MediaWikiPHPUnitCommand::$additionalOptions[$offset] = $value;
    }

    function hideDeprecated( $function ) {
        wfSuppressWarnings();
        wfDeprecated( $function );
        wfRestoreWarnings();
    }

    protected function assertSelect( $table, $fields, $condition, array $expectedRows ) {
        if ( !$this->needsDB() ) {
            throw new MWException( 'When testing database state, the test cases\'s needDB()' .
                ' method should return true. Use @group Database or $this->tablesUsed.' );
        }

        $db = wfGetDB( DB_SLAVE );

        $res = $db->select( $table, $fields, $condition, wfGetCaller(), array( 'ORDER BY' => $fields ) );
        $this->assertNotEmpty( $res, "query failed: " . $db->lastError() );

        $i = 0;

        foreach ( $expectedRows as $expected ) {
            $r = $res->fetchRow();
            self::stripStringKeys( $r );

            $i += 1;
            $this->assertNotEmpty( $r, "row #$i missing" );

            $this->assertEquals( $expected, $r, "row #$i mismatches" );
        }

        $r = $res->fetchRow();
        self::stripStringKeys( $r );

        $this->assertFalse( $r, "found extra row (after #$i)" );
    }

    protected function arrayWrap( array $elements ) {
        return array_map(
            function ( $element ) {
                return array( $element );
            },
            $elements
        );
    }

    protected function assertArrayEquals( array $expected, array $actual, $ordered = false, $named = false ) {
        if ( !$ordered ) {
            $this->objectAssociativeSort( $expected );
            $this->objectAssociativeSort( $actual );
        }

        if ( !$named ) {
            $expected = array_values( $expected );
            $actual = array_values( $actual );
        }

        call_user_func_array(
            array( $this, 'assertEquals' ),
            array_merge( array( $expected, $actual ), array_slice( func_get_args(), 4 ) )
        );
    }

    protected function assertHTMLEquals( $expected, $actual, $msg = '' ) {
        $expected = str_replace( '>', ">\n", $expected );
        $actual = str_replace( '>', ">\n", $actual );

        $this->assertEquals( $expected, $actual, $msg );
    }

    protected function objectAssociativeSort( array &$array ) {
        uasort(
            $array,
            function ( $a, $b ) {
                return serialize( $a ) > serialize( $b ) ? 1 : -1;
            }
        );
    }

    protected static function stripStringKeys( &$r ) {
        if ( !is_array( $r ) ) {
            return;
        }

        foreach ( $r as $k => $v ) {
            if ( is_string( $k ) ) {
                unset( $r[$k] );
            }
        }
    }

    protected function assertTypeOrValue( $type, $actual, $value = false, $message = '' ) {
        if ( $actual === $value ) {
            $this->assertTrue( true, $message );
        } else {
            $this->assertType( $type, $actual, $message );
        }
    }

    protected function assertType( $type, $actual, $message = '' ) {
        if ( class_exists( $type ) || interface_exists( $type ) ) {
            $this->assertInstanceOf( $type, $actual, $message );
        } else {
            $this->assertInternalType( $type, $actual, $message );
        }
    }

    protected function isWikitextNS( $ns ) {
        global $wgNamespaceContentModels;

        if ( isset( $wgNamespaceContentModels[$ns] ) ) {
            return $wgNamespaceContentModels[$ns] === CONTENT_MODEL_WIKITEXT;
        }

        return true;
    }

    protected function getDefaultWikitextNS() {
        global $wgNamespaceContentModels;

        static $wikitextNS = null; // this is not going to change
        if ( $wikitextNS !== null ) {
            return $wikitextNS;
        }

        // quickly short out on most common case:
        if ( !isset( $wgNamespaceContentModels[NS_MAIN] ) ) {
            return NS_MAIN;
        }

        // NOTE: prefer content namespaces
        $namespaces = array_unique( array_merge(
            MWNamespace::getContentNamespaces(),
            array( NS_MAIN, NS_HELP, NS_PROJECT ), // prefer these
            MWNamespace::getValidNamespaces()
        ) );

        $namespaces = array_diff( $namespaces, array(
            NS_FILE, NS_CATEGORY, NS_MEDIAWIKI, NS_USER // don't mess with magic namespaces
        ) );

        $talk = array_filter( $namespaces, function ( $ns ) {
            return MWNamespace::isTalk( $ns );
        } );

        // prefer non-talk pages
        $namespaces = array_diff( $namespaces, $talk );
        $namespaces = array_merge( $namespaces, $talk );

        // check default content model of each namespace
        foreach ( $namespaces as $ns ) {
            if ( !isset( $wgNamespaceContentModels[$ns] ) ||
                $wgNamespaceContentModels[$ns] === CONTENT_MODEL_WIKITEXT
            ) {

                $wikitextNS = $ns;

                return $wikitextNS;
            }
        }

        // give up
        // @todo Inside a test, we could skip the test as incomplete.
        //        But frequently, this is used in fixture setup.
        throw new MWException( "No namespace defaults to wikitext!" );
    }

    protected function checkHasDiff3() {
        global $wgDiff3;

        # This check may also protect against code injection in
        # case of broken installations.
        wfSuppressWarnings();
        $haveDiff3 = $wgDiff3 && file_exists( $wgDiff3 );
        wfRestoreWarnings();

        if ( !$haveDiff3 ) {
            $this->markTestSkipped( "Skip test, since diff3 is not configured" );
        }
    }

    protected function checkHasGzip() {
        static $haveGzip;

        if ( $haveGzip === null ) {
            $retval = null;
            wfShellExec( 'gzip -V', $retval );
            $haveGzip = ( $retval === 0 );
        }

        if ( !$haveGzip ) {
            $this->markTestSkipped( "Skip test, requires the gzip utility in PATH" );
        }

        return $haveGzip;
    }

    protected function checkPHPExtension( $extName ) {
        $loaded = extension_loaded( $extName );
        if ( !$loaded ) {
            $this->markTestSkipped( "PHP extension '$extName' is not loaded, skipping." );
        }

        return $loaded;
    }

    protected function assertException( $code, $expected = 'Exception', $message = '' ) {
        $pokemons = null;

        try {
            call_user_func( $code );
        } catch ( Exception $pokemons ) {
            // Gotta Catch 'Em All!
        }

        if ( $message === '' ) {
            $message = 'An exception of type "' . $expected . '" should have been thrown';
        }

        $this->assertInstanceOf( $expected, $pokemons, $message );
    }
}