DumpAsserter.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\Tests\Maintenance;
 
use PHPUnit\Framework\Assert;
use XMLReader;
 
class DumpAsserter {
 
    protected $xml = null;
 
    protected $schemaVersion;
 
    public function __construct( $schemaVersion ) {
        $this->schemaVersion = $schemaVersion;
    }
 
    public function skipToNodeEnd( $name ) {
        while ( $this->xml->read() ) {
            if ( $this->xml->nodeType == XMLReader::END_ELEMENT &&
                $this->xml->name == $name
            ) {
                return true;
            }
        }
 
        return false;
    }
 
    public function skipPastNodeEnd( $name ) {
        Assert::assertTrue( $this->skipToNodeEnd( $name ),
            "Skipping to end of $name" );
        while ( $this->xml->read() ) {
            if ( $this->xml->nodeType == XMLReader::ELEMENT ) {
                return true;
            }
        }
 
        return false;
    }
 
    public function assertDumpStart( $fname, $skip_siteinfo = true ) {
        $this->xml = new XMLReader();
 
        Assert::assertTrue( $this->xml->open( $fname ),
            "Opening temporary file $fname via XMLReader failed" );
        if ( $skip_siteinfo ) {
            Assert::assertTrue( $this->skipPastNodeEnd( "siteinfo" ),
                "Skipping past end of siteinfo" );
        }
    }
 
    public function assertDumpEnd( $name = "mediawiki" ) {
        $this->assertNodeEnd( $name, false );
        if ( $this->xml->read() ) {
            $this->skipWhitespace();
        }
        Assert::assertEquals( $this->xml->nodeType, XMLReader::NONE,
            "No proper entity left to parse" );
        $this->xml->close();
    }
 
    public function skipWhitespace() {
        $cont = true;
        while ( $cont && ( ( $this->xml->nodeType == XMLReader::WHITESPACE )
            || ( $this->xml->nodeType == XMLReader::SIGNIFICANT_WHITESPACE ) ) ) {
            $cont = $this->xml->read();
        }
    }
 
    public function assertNodeStart( $name, $skip = true ) {
        Assert::assertEquals( $name, $this->xml->name, "Node name" );
        Assert::assertEquals( XMLReader::ELEMENT, $this->xml->nodeType, "Node type" );
        if ( $skip ) {
            Assert::assertTrue( $this->xml->read(), "Skipping past start tag" );
        }
    }
 
    public function assertNodeEnd( $name, $skip = true ) {
        Assert::assertEquals( $name, $this->xml->name, "Node name" );
        Assert::assertEquals( XMLReader::END_ELEMENT, $this->xml->nodeType, "Node type" );
        if ( $skip ) {
            Assert::assertTrue( $this->xml->read(), "Skipping past end tag" );
        }
    }
 
    public function assertTextNode( $name, $text, $skip_ws = true ) {
        $this->assertNodeStart( $name );
 
        if ( $text !== false ) {
            Assert::assertEquals( $text, $this->xml->value, "Text of node " . $name );
        }
        Assert::assertTrue( $this->xml->read(), "Skipping past processed text of " . $name );
        $this->assertNodeEnd( $name );
 
        if ( $skip_ws ) {
            $this->skipWhitespace();
        }
    }
 
    public function assertPageStart( $id, $ns, $name ) {
        $this->assertNodeStart( "page" );
        $this->skipWhitespace();
 
        $this->assertTextNode( "title", $name );
        $this->assertTextNode( "ns", $ns );
        $this->assertTextNode( "id", $id );
    }
 
    public function assertPageEnd() {
        $this->assertNodeEnd( "page" );
        $this->skipWhitespace();
    }
 
    public 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( "username", false );
        $this->assertTextNode( "id", 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();
    }
 
    public function assertText( $id, $text_id, $text_bytes, $text ) {
        $this->assertNodeStart( "text", false );
        if ( $text_bytes !== false ) {
            Assert::assertEquals( $this->xml->getAttribute( "bytes" ), $text_bytes,
                "Attribute 'bytes' of revision " . $id );
        }
 
        if ( $text === false ) {
            // Testing for a stub
            Assert::assertEquals( $this->xml->getAttribute( "id" ), $text_id,
                "Text id of revision " . $id );
            Assert::assertFalse( $this->xml->hasValue, "Revision has text" );
            Assert::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
            Assert::assertTrue( $this->xml->read(), "Skipping text start tag" );
            Assert::assertEquals( $text, $this->xml->value, "Text of revision " . $id );
            Assert::assertTrue( $this->xml->read(), "Skipping past text" );
            $this->assertNodeEnd( "text" );
            $this->skipWhitespace();
        }
    }
 
    public function assertLogItem( $id, $user_name, $user_id, $comment, $type,
        $subtype, $title, $parameters = []
    ) {
        $this->assertNodeStart( "logitem" );
        $this->skipWhitespace();
 
        $this->assertTextNode( "id", $id );
        $this->assertTextNode( "timestamp", false );
 
        $this->assertNodeStart( "contributor" );
        $this->skipWhitespace();
        $this->assertTextNode( "username", $user_name );
        $this->assertTextNode( "id", $user_id );
        $this->assertNodeEnd( "contributor" );
        $this->skipWhitespace();
 
        if ( $comment !== null ) {
            $this->assertTextNode( "comment", $comment );
        }
        $this->assertTextNode( "type", $type );
        $this->assertTextNode( "action", $subtype );
        $this->assertTextNode( "logtitle", $title );
 
        $this->assertNodeStart( "params" );
        $parameters_xml = unserialize( $this->xml->value );
        Assert::assertEquals( $parameters, $parameters_xml );
        Assert::assertTrue( $this->xml->read(), "Skipping past processed text of params" );
        $this->assertNodeEnd( "params" );
        $this->skipWhitespace();
 
        $this->assertNodeEnd( "logitem" );
        $this->skipWhitespace();
    }
}