DumpTestCase.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\Tests\Maintenance;
 
use ContentHandler;
use ExecutableFinder;
use MediaWikiLangTestCase;
use Page;
use User;
use XMLReader;
use MWException;
 
abstract class DumpTestCase extends MediaWikiLangTestCase {
 
    protected $exceptionFromAddDBData = null;
 
    protected $xml = null;
 
    protected static $hasGzip = null;
 
    protected function checkHasGzip() {
        if ( self::$hasGzip === null ) {
            self::$hasGzip = ( ExecutableFinder::findInDefaultPaths( 'gzip' ) !== false );
        }
 
        if ( !self::$hasGzip ) {
            $this->markTestSkipped( "Skip test, requires the gzip utility in PATH" );
        }
 
        return self::$hasGzip;
    }
 
    protected function addRevision( Page $page, $text, $summary, $model = CONTENT_MODEL_WIKITEXT ) {
        $status = $page->doEditContent(
            ContentHandler::makeContent( $text, $page->getTitle(), $model ),
            $summary
        );
 
        if ( $status->isGood() ) {
            $value = $status->getValue();
            $revision = $value['revision'];
            $revision_id = $revision->getId();
            $text_id = $revision->getTextId();
 
            if ( ( $revision_id > 0 ) && ( $text_id > 0 ) ) {
                return [ $revision_id, $text_id ];
            }
        }
 
        throw new MWException( "Could not determine revision id ("
            . $status->getWikiText( false, false, 'en' ) . ")" );
    }
 
    protected function gunzip( $fname ) {
        $gzipped_contents = file_get_contents( $fname );
        if ( $gzipped_contents === false ) {
            $this->fail( "Could not get contents of $fname" );
        }
 
        $contents = gzdecode( $gzipped_contents );
 
        $this->assertEquals(
            strlen( $contents ),
            file_put_contents( $fname, $contents ),
            '# bytes written'
        );
    }
 
    protected function setUp() {
        parent::setUp();
 
        // Check if any Exception is stored for rethrowing from addDBData
        // @see self::exceptionFromAddDBData
        if ( $this->exceptionFromAddDBData !== null ) {
            throw $this->exceptionFromAddDBData;
        }
 
        $this->setMwGlobals( 'wgUser', new User() );
    }
 
    function expectETAOutput() {
        // Newer PHPUnits require assertion about the output using PHPUnit's own
        // expectOutput[...] functions. However, the PHPUnit shipped prediactes
        // do not allow to check /each/ line of the output using /readable/ REs.
        // So we ...
 
        // 1. ... add a dummy output checking to make PHPUnit not complain
        //    about unchecked test output
        $this->expectOutputRegex( '//' );
 
        // 2. Do the real output checking on our own.
        $lines = explode( "\n", $this->getActualOutput() );
        $this->assertGreaterThan( 1, count( $lines ), "Minimal lines of produced output" );
        $this->assertEquals( '', array_pop( $lines ), "Output ends in LF" );
        $timestamp_re = "[0-9]{4}-[01][0-9]-[0-3][0-9] [0-2][0-9]:[0-5][0-9]:[0-6][0-9]";
        foreach ( $lines as $line ) {
            $this->assertRegExp(
                "/$timestamp_re: .* \‍(ID [0-9]+\‍) [0-9]* pages .*, [0-9]* revs .*, ETA/",
                $line
            );
        }
    }
 
    protected function skipToNodeEnd( $name ) {
        while ( $this->xml->read() ) {
            if ( $this->xml->nodeType == XMLReader::END_ELEMENT &&
                $this->xml->name == $name
            ) {
                return true;
            }
        }
 
        return false;
    }
 
    protected function skipPastNodeEnd( $name ) {
        $this->assertTrue( $this->skipToNodeEnd( $name ),
            "Skipping to end of $name" );
        while ( $this->xml->read() ) {
            if ( $this->xml->nodeType == XMLReader::ELEMENT ) {
                return true;
            }
        }
 
        return false;
    }
 
    protected function assertDumpStart( $fname, $skip_siteinfo = true ) {
        $this->xml = new XMLReader();
        $this->assertTrue( $this->xml->open( $fname ),
            "Opening temporary file $fname via XMLReader failed" );
        if ( $skip_siteinfo ) {
            $this->assertTrue( $this->skipPastNodeEnd( "siteinfo" ),
                "Skipping past end of siteinfo" );
        }
    }
 
    protected function assertDumpEnd( $name = "mediawiki" ) {
        $this->assertNodeEnd( $name, false );
        if ( $this->xml->read() ) {
            $this->skipWhitespace();
        }
        $this->assertEquals( $this->xml->nodeType, XMLReader::NONE,
            "No proper entity left to parse" );
        $this->xml->close();
    }
 
    protected function skipWhitespace() {
        $cont = true;
        while ( $cont && ( ( $this->xml->nodeType == XMLReader::WHITESPACE )
            || ( $this->xml->nodeType == XMLReader::SIGNIFICANT_WHITESPACE ) ) ) {
            $cont = $this->xml->read();
        }
    }
 
    protected function assertNodeStart( $name, $skip = true ) {
        $this->assertEquals( $name, $this->xml->name, "Node name" );
        $this->assertEquals( XMLReader::ELEMENT, $this->xml->nodeType, "Node type" );
        if ( $skip ) {
            $this->assertTrue( $this->xml->read(), "Skipping past start tag" );
        }
    }
 
    protected function assertNodeEnd( $name, $skip = true ) {
        $this->assertEquals( $name, $this->xml->name, "Node name" );
        $this->assertEquals( XMLReader::END_ELEMENT, $this->xml->nodeType, "Node type" );
        if ( $skip ) {
            $this->assertTrue( $this->xml->read(), "Skipping past end tag" );
        }
    }
 
    protected function assertTextNode( $name, $text, $skip_ws = true ) {
        $this->assertNodeStart( $name );
 
        if ( $text !== false ) {
            $this->assertEquals( $text, $this->xml->value, "Text of node " . $name );
        }
        $this->assertTrue( $this->xml->read(), "Skipping past processed text of " . $name );
        $this->assertNodeEnd( $name );
 
        if ( $skip_ws ) {
            $this->skipWhitespace();
        }
    }
 
    protected function assertPageStart( $id, $ns, $name ) {
        $this->assertNodeStart( "page" );
        $this->skipWhitespace();
 
        $this->assertTextNode( "title", $name );
        $this->assertTextNode( "ns", $ns );
        $this->assertTextNode( "id", $id );
    }
 
    protected function assertPageEnd() {
        $this->assertNodeEnd( "page" );
        $this->skipWhitespace();
    }
 
    protected function assertRevision( $id, $summary, $text_id, $text_bytes,
        $text_sha1, $text = false, $parentid = false,
        $model = CONTENT_MODEL_WIKITEXT, $format = CONTENT_FORMAT_WIKITEXT
    ) {
        $this->assertNodeStart( "revision" );
        $this->skipWhitespace();
 
        $this->assertTextNode( "id", $id );
        if ( $parentid !== false ) {
            $this->assertTextNode( "parentid", $parentid );
        }
        $this->assertTextNode( "timestamp", false );
 
        $this->assertNodeStart( "contributor" );
        $this->skipWhitespace();
        $this->assertTextNode( "ip", false );
        $this->assertNodeEnd( "contributor" );
        $this->skipWhitespace();
 
        $this->assertTextNode( "comment", $summary );
        $this->skipWhitespace();
 
        $this->assertTextNode( "model", $model );
        $this->skipWhitespace();
 
        $this->assertTextNode( "format", $format );
        $this->skipWhitespace();
 
        if ( $this->xml->name == "text" ) {
            // note: <text> tag may occur here or at the very end.
            $text_found = true;
            $this->assertText( $id, $text_id, $text_bytes, $text );
        } else {
            $text_found = false;
        }
 
        $this->assertTextNode( "sha1", $text_sha1 );
 
        if ( !$text_found ) {
            $this->assertText( $id, $text_id, $text_bytes, $text );
        }
 
        $this->assertNodeEnd( "revision" );
        $this->skipWhitespace();
    }
 
    protected function assertText( $id, $text_id, $text_bytes, $text ) {
        $this->assertNodeStart( "text", false );
        if ( $text_bytes !== false ) {
            $this->assertEquals( $this->xml->getAttribute( "bytes" ), $text_bytes,
                "Attribute 'bytes' of revision " . $id );
        }
 
        if ( $text === false ) {
            // Testing for a stub
            $this->assertEquals( $this->xml->getAttribute( "id" ), $text_id,
                "Text id of revision " . $id );
            $this->assertFalse( $this->xml->hasValue, "Revision has text" );
            $this->assertTrue( $this->xml->read(), "Skipping text start tag" );
            if ( ( $this->xml->nodeType == XMLReader::END_ELEMENT )
                && ( $this->xml->name == "text" )
            ) {
                $this->xml->read();
            }
            $this->skipWhitespace();
        } else {
            // Testing for a real dump
            $this->assertTrue( $this->xml->read(), "Skipping text start tag" );
            $this->assertEquals( $text, $this->xml->value, "Text of revision " . $id );
            $this->assertTrue( $this->xml->read(), "Skipping past text" );
            $this->assertNodeEnd( "text" );
            $this->skipWhitespace();
        }
    }
}