tests/phpunit/maintenance/DumpTestCase.php

   1 <?php
   2
   3 /**
   4  * Base TestCase for dumps
   5  */
   6 abstract class DumpTestCase extends MediaWikiLangTestCase {
   7
   8         /**
   9          * exception to be rethrown once in sound PHPUnit surrounding
  10          *
  11          * As the current MediaWikiTestCase::run is not robust enough to recover
  12          * from thrown exceptions directly, we cannot throw frow within
  13          * self::addDBData, although it would be appropriate. Hence, we catch the
  14          * exception and store it until we are in setUp and may finally rethrow
  15          * the exception without crashing the test suite.
  16          *
  17          * @var Exception|null
  18          */
  19         protected $exceptionFromAddDBData = null;
  20
  21         /**
  22          * Holds the xmlreader used for analyzing an xml dump
  23          *
  24          * @var XMLReader|null
  25          */
  26         protected $xml = null;
  27
  28         /**
  29          * Adds a revision to a page, while returning the resuting revision's id
  30          *
  31          * @param $page WikiPage: page to add the revision to
  32          * @param $text string: revisions text
  33          * @param $text string: revisions summare
  34          *
  35          * @throws MWExcepion
  36          */
  37         protected function addRevision( Page $page, $text, $summary ) {
  38                 $status = $page->doEditContent( ContentHandler::makeContent( $text, $page->getTitle() ), $summary );
  39                 if ( $status->isGood() ) {
  40                         $value = $status->getValue();
  41                         $revision = $value['revision'];
  42                         $revision_id = $revision->getId();
  43                         $text_id = $revision->getTextId();
  44                         if ( ( $revision_id > 0 ) && ( $text_id > 0 ) ) {
  45                                 return array( $revision_id, $text_id );
  46                         }
  47                 }
  48                 throw new MWException( "Could not determine revision id (" . $status->getWikiText() . ")" );
  49         }
  50
  51
  52         /**
  53          * gunzips the given file and stores the result in the original file name
  54          *
  55          * @param $fname string: filename to read the gzipped data from and stored
  56          *             the gunzipped data into
  57          */
  58         protected function gunzip( $fname ) {
  59                 $gzipped_contents = file_get_contents( $fname );
  60                 if ( $gzipped_contents === false ) {
  61                         $this->fail( "Could not get contents of $fname" );
  62                 }
  63                 // We resort to use gzinflate instead of gzdecode, as gzdecode
  64                 // need not be available
  65                 $contents = gzinflate( substr( $gzipped_contents, 10, -8 ) );
  66                 $this->assertEquals( strlen( $contents ),
  67                         file_put_contents( $fname, $contents ), "# bytes written" );
  68         }
  69
  70         /**
  71          * Default set up function.
  72          *
  73          * Clears $wgUser, and reports errors from addDBData to PHPUnit
  74          */
  75         protected function setUp() {
  76                 global $wgUser;
  77
  78                 parent::setUp();
  79
  80                 // Check if any Exception is stored for rethrowing from addDBData
  81                 // @see self::exceptionFromAddDBData
  82                 if ( $this->exceptionFromAddDBData !== null ) {
  83                         throw $this->exceptionFromAddDBData;
  84                 }
  85
  86                 $wgUser = new User();
  87         }
  88
  89         /**
  90          * Checks for test output consisting only of lines containing ETA announcements
  91          */
  92         function expectETAOutput() {
  93                 // Newer PHPUnits require assertion about the output using PHPUnit's own
  94                 // expectOutput[...] functions. However, the PHPUnit shipped prediactes
  95                 // do not allow to check /each/ line of the output using /readable/ REs.
  96                 // So we ...
  97                 //
  98                 // 1. ... add a dummy output checking to make PHPUnit not complain
  99                 //    about unchecked test output
 100                 $this->expectOutputRegex( '//' );
 101
 102                 // 2. Do the real output checking on our own.
 103                 $lines = explode( "\n", $this->getActualOutput() );
 104                 $this->assertGreaterThan( 1, count( $lines ), "Minimal lines of produced output" );
 105                 $this->assertEquals( '', array_pop( $lines ), "Output ends in LF" );
 106                 $timestamp_re = "[0-9]{4}-[01][0-9]-[0-3][0-9] [0-2][0-9]:[0-5][0-9]:[0-6][0-9]";
 107                 foreach ( $lines as $line ) {
 108                         $this->assertRegExp( "/$timestamp_re: .* \(ID [0-9]+\) [0-9]* pages .*, [0-9]* revs .*, ETA/", $line );
 109                 }
 110         }
 111
 112
 113         /**
 114          * Step the current XML reader until node end of given name is found.
 115          *
 116          * @param $name string: name of the closing element to look for
 117          *           (e.g.: "mediawiki" when looking for </mediawiki>)
 118          *
 119          * @return bool: true iff the end node could be found. false otherwise.
 120          */
 121         protected function skipToNodeEnd( $name ) {
 122                 while ( $this->xml->read() ) {
 123                         if ( $this->xml->nodeType == XMLReader::END_ELEMENT &&
 124                                 $this->xml->name == $name
 125                         ) {
 126                                 return true;
 127                         }
 128                 }
 129                 return false;
 130         }
 131
 132         /**
 133          * Step the current XML reader to the first element start after the node
 134          * end of a given name.
 135          *
 136          * @param $name string: name of the closing element to look for
 137          *           (e.g.: "mediawiki" when looking for </mediawiki>)
 138          *
 139          * @return bool: true iff new element after the closing of $name could be
 140          *           found. false otherwise.
 141          */
 142         protected function skipPastNodeEnd( $name ) {
 143                 $this->assertTrue( $this->skipToNodeEnd( $name ),
 144                         "Skipping to end of $name" );
 145                 while ( $this->xml->read() ) {
 146                         if ( $this->xml->nodeType == XMLReader::ELEMENT ) {
 147                                 return true;
 148                         }
 149                 }
 150                 return false;
 151         }
 152
 153         /**
 154          * Opens an XML file to analyze and optionally skips past siteinfo.
 155          *
 156          * @param $fname string: name of file to analyze
 157          * @param $skip_siteinfo bool: (optional) If true, step the xml reader
 158          *           to the first element after </siteinfo>
 159          */
 160         protected function assertDumpStart( $fname, $skip_siteinfo = true ) {
 161                 $this->xml = new XMLReader();
 162                 $this->assertTrue( $this->xml->open( $fname ),
 163                         "Opening temporary file $fname via XMLReader failed" );
 164                 if ( $skip_siteinfo ) {
 165                         $this->assertTrue( $this->skipPastNodeEnd( "siteinfo" ),
 166                                 "Skipping past end of siteinfo" );
 167                 }
 168         }
 169
 170         /**
 171          * Asserts that the xml reader is at the final closing tag of an xml file and
 172          * closes the reader.
 173          *
 174          * @param $tag string: (optional) the name of the final tag
 175          *           (e.g.: "mediawiki" for </mediawiki>)
 176          */
 177         protected function assertDumpEnd( $name = "mediawiki" ) {
 178                 $this->assertNodeEnd( $name, false );
 179                 if ( $this->xml->read() ) {
 180                         $this->skipWhitespace();
 181                 }
 182                 $this->assertEquals( $this->xml->nodeType, XMLReader::NONE,
 183                         "No proper entity left to parse" );
 184                 $this->xml->close();
 185         }
 186
 187         /**
 188          * Steps the xml reader over white space
 189          */
 190         protected function skipWhitespace() {
 191                 $cont = true;
 192                 while ( $cont && ( ( $this->xml->nodeType == XMLReader::WHITESPACE )
 193                         || ( $this->xml->nodeType == XMLReader::SIGNIFICANT_WHITESPACE ) ) ) {
 194                         $cont = $this->xml->read();
 195                 }
 196         }
 197
 198         /**
 199          * Asserts that the xml reader is at an element of given name, and optionally
 200          * skips past it.
 201          *
 202          * @param $name string: the name of the element to check for
 203          *           (e.g.: "mediawiki" for <mediawiki>)
 204          * @param $skip bool: (optional) if true, skip past the found element
 205          */
 206         protected function assertNodeStart( $name, $skip = true ) {
 207                 $this->assertEquals( $name, $this->xml->name, "Node name" );
 208                 $this->assertEquals( XMLReader::ELEMENT, $this->xml->nodeType, "Node type" );
 209                 if ( $skip ) {
 210                         $this->assertTrue( $this->xml->read(), "Skipping past start tag" );
 211                 }
 212         }
 213
 214         /**
 215          * Asserts that the xml reader is at an closing element of given name, and optionally
 216          * skips past it.
 217          *
 218          * @param $name string: the name of the closing element to check for
 219          *           (e.g.: "mediawiki" for </mediawiki>)
 220          * @param $skip bool: (optional) if true, skip past the found element
 221          */
 222         protected function assertNodeEnd( $name, $skip = true ) {
 223                 $this->assertEquals( $name, $this->xml->name, "Node name" );
 224                 $this->assertEquals( XMLReader::END_ELEMENT, $this->xml->nodeType, "Node type" );
 225                 if ( $skip ) {
 226                         $this->assertTrue( $this->xml->read(), "Skipping past end tag" );
 227                 }
 228         }
 229
 230
 231         /**
 232          * Asserts that the xml reader is at an element of given tag that contains a given text,
 233          * and skips over the element.
 234          *
 235          * @param $name string: the name of the element to check for
 236          *           (e.g.: "mediawiki" for <mediawiki>...</mediawiki>)
 237          * @param $text string|false: If string, check if it equals the elements text.
 238          *           If false, ignore the element's text
 239          * @param $skip_ws bool: (optional) if true, skip past white spaces that trail the
 240          *           closing element.
 241          */
 242         protected function assertTextNode( $name, $text, $skip_ws = true ) {
 243                 $this->assertNodeStart( $name );
 244
 245                 if ( $text !== false ) {
 246                         $this->assertEquals( $text, $this->xml->value, "Text of node " . $name );
 247                 }
 248                 $this->assertTrue( $this->xml->read(), "Skipping past processed text of " . $name );
 249                 $this->assertNodeEnd( $name );
 250
 251                 if ( $skip_ws ) {
 252                         $this->skipWhitespace();
 253                 }
 254         }
 255
 256         /**
 257          * Asserts that the xml reader is at the start of a page element and skips over the first
 258          * tags, after checking them.
 259          *
 260          * Besides the opening page element, this function also checks for and skips over the
 261          * title, ns, and id tags. Hence after this function, the xml reader is at the first
 262          * revision of the current page.
 263          *
 264          * @param $id int: id of the page to assert
 265          * @param $ns int: number of namespage to assert
 266          * @param $name string: title of the current page
 267          */
 268         protected function assertPageStart( $id, $ns, $name ) {
 269
 270                 $this->assertNodeStart( "page" );
 271                 $this->skipWhitespace();
 272
 273                 $this->assertTextNode( "title", $name );
 274                 $this->assertTextNode( "ns", $ns );
 275                 $this->assertTextNode( "id", $id );
 276
 277         }
 278
 279         /**
 280          * Asserts that the xml reader is at the page's closing element and skips to the next
 281          * element.
 282          */
 283         protected function assertPageEnd() {
 284                 $this->assertNodeEnd( "page" );
 285                 $this->skipWhitespace();
 286         }
 287
 288         /**
 289          * Asserts that the xml reader is at a revision and checks its representation before
 290          * skipping over it.
 291          *
 292          * @param $id int: id of the revision
 293          * @param $summary string: summary of the revision
 294          * @param $text_id int: id of the revision's text
 295          * @param $text_bytes int: # of bytes in the revision's text
 296          * @param $text_sha1 string: the base36 SHA-1 of the revision's text
 297          * @param $text string|false: (optional) The revision's string, or false to check for a
 298          *            revision stub
 299          * @param $model String: the expected content model id (default: CONTENT_MODEL_WIKITEXT)
 300          * @param $format String: the expected format model id (default: CONTENT_FORMAT_WIKITEXT)
 301          * @param $parentid int|false: (optional) id of the parent revision
 302          */
 303         protected function assertRevision( $id, $summary, $text_id, $text_bytes, $text_sha1, $text = false, $parentid = false,
 304                                                                            $model = CONTENT_MODEL_WIKITEXT, $format = CONTENT_FORMAT_WIKITEXT ) {
 305
 306                 $this->assertNodeStart( "revision" );
 307                 $this->skipWhitespace();
 308
 309                 $this->assertTextNode( "id", $id );
 310                 if ( $parentid !== false ) {
 311                         $this->assertTextNode( "parentid", $parentid );
 312                 }
 313                 $this->assertTextNode( "timestamp", false );
 314
 315                 $this->assertNodeStart( "contributor" );
 316                 $this->skipWhitespace();
 317                 $this->assertTextNode( "ip", false );
 318                 $this->assertNodeEnd( "contributor" );
 319                 $this->skipWhitespace();
 320
 321                 $this->assertTextNode( "comment", $summary );
 322                 $this->skipWhitespace();
 323
 324                 if ( $this->xml->name == "text" ) {
 325                         // note: <text> tag may occur here or at the very end.
 326                         $text_found = true;
 327                         $this->assertText( $id, $text_id, $text_bytes, $text );
 328                 } else {
 329                         $text_found = false;
 330                 }
 331
 332                 $this->assertTextNode( "sha1", $text_sha1 );
 333
 334                 $this->assertTextNode( "model", $model );
 335                 $this->skipWhitespace();
 336
 337                 $this->assertTextNode( "format", $format );
 338                 $this->skipWhitespace();
 339
 340                 if ( !$text_found ) {
 341                         $this->assertText( $id, $text_id, $text_bytes, $text );
 342                 }
 343
 344                 $this->assertNodeEnd( "revision" );
 345                 $this->skipWhitespace();
 346         }
 347
 348         protected function assertText( $id, $text_id, $text_bytes, $text ) {
 349                 $this->assertNodeStart( "text", false );
 350                 if ( $text_bytes !== false ) {
 351                         $this->assertEquals( $this->xml->getAttribute( "bytes" ), $text_bytes,
 352                                 "Attribute 'bytes' of revision " . $id );
 353                 }
 354
 355                 if ( $text === false ) {
 356                         // Testing for a stub
 357                         $this->assertEquals( $this->xml->getAttribute( "id" ), $text_id,
 358                                 "Text id of revision " . $id );
 359                         $this->assertFalse( $this->xml->hasValue, "Revision has text" );
 360                         $this->assertTrue( $this->xml->read(), "Skipping text start tag" );
 361                         if ( ( $this->xml->nodeType == XMLReader::END_ELEMENT )
 362                                 && ( $this->xml->name == "text" )
 363                         ) {
 364
 365                                 $this->xml->read();
 366                         }
 367                         $this->skipWhitespace();
 368                 } else {
 369                         // Testing for a real dump
 370                         $this->assertTrue( $this->xml->read(), "Skipping text start tag" );
 371                         $this->assertEquals( $text, $this->xml->value, "Text of revision " . $id );
 372                         $this->assertTrue( $this->xml->read(), "Skipping past text" );
 373                         $this->assertNodeEnd( "text" );
 374                         $this->skipWhitespace();
 375                 }
 376         }
 377 }