tests/phpunit/includes/import/ImportExportTest.php

   1 <?php
   2
   3 use MediaWiki\Config\HashConfig;
   4 use MediaWiki\MainConfigNames;
   5 use MediaWiki\Revision\RevisionRecord;
   6 use MediaWiki\Tests\Maintenance\DumpAsserter;
   7 use MediaWiki\Title\Title;
   8 use Wikimedia\Rdbms\IDBAccessObject;
   9 use Wikimedia\Rdbms\SelectQueryBuilder;
  10
  11 /**
  12  * Import/export round trip test.
  13  *
  14  * @group Database
  15  * @covers \WikiExporter
  16  * @covers \WikiImporter
  17  */
  18 class ImportExportTest extends MediaWikiLangTestCase {
  19
  20         protected function setUp(): void {
  21                 parent::setUp();
  22
  23                 $slotRoleRegistry = $this->getServiceContainer()->getSlotRoleRegistry();
  24
  25                 if ( !$slotRoleRegistry->isDefinedRole( 'ImportExportTest' ) ) {
  26                         $slotRoleRegistry->defineRoleWithModel( 'ImportExportTest', CONTENT_MODEL_WIKITEXT );
  27                 }
  28         }
  29
  30         /**
  31          * @param string $schemaVersion
  32          *
  33          * @return WikiExporter
  34          */
  35         private function getExporter( string $schemaVersion ) {
  36                 $exporter = $this->getServiceContainer()
  37                         ->getWikiExporterFactory()
  38                         ->getWikiExporter( $this->getDb(), WikiExporter::FULL );
  39                 $exporter->setSchemaVersion( $schemaVersion );
  40                 return $exporter;
  41         }
  42
  43         /**
  44          * @param ImportSource $source
  45          *
  46          * @return WikiImporter
  47          */
  48         private function getImporter( ImportSource $source ) {
  49                 $config = new HashConfig( [
  50                         MainConfigNames::MaxArticleSize => 2048,
  51                 ] );
  52                 $services = $this->getServiceContainer();
  53                 $importer = new WikiImporter(
  54                         $source,
  55                         $this->getTestSysop()->getAuthority(),
  56                         $config,
  57                         $services->getHookContainer(),
  58                         $services->getContentLanguage(),
  59                         $services->getNamespaceInfo(),
  60                         $services->getTitleFactory(),
  61                         $services->getWikiPageFactory(),
  62                         $services->getWikiRevisionUploadImporter(),
  63                         $services->getContentHandlerFactory(),
  64                         $services->getSlotRoleRegistry()
  65                 );
  66                 return $importer;
  67         }
  68
  69         /**
  70          * @param string $testName
  71          *
  72          * @return string[]
  73          */
  74         private function getFilesToImport( string $testName ) {
  75                 return glob( __DIR__ . "/../../data/import/$testName.import-*.xml" );
  76         }
  77
  78         /**
  79          * @param string $name
  80          * @param string $schemaVersion
  81          *
  82          * @return string path of the dump file
  83          */
  84         protected function getDumpTemplatePath( $name, $schemaVersion ) {
  85                 return __DIR__ . "/../../data/import/$name.$schemaVersion.xml";
  86         }
  87
  88         /**
  89          * @param string $prefix
  90          * @param string[] $keys
  91          *
  92          * @return string[]
  93          */
  94         private function getUniqueNames( string $prefix, array $keys ) {
  95                 $names = [];
  96
  97                 foreach ( $keys as $k ) {
  98                         $names[$k] = "$prefix-$k-" . wfRandomString( 6 );
  99                 }
 100
 101                 return $names;
 102         }
 103
 104         /**
 105          * @param string $xmlData
 106          * @param string[] $pageTitles
 107          *
 108          * @return string
 109          */
 110         private function injectPageTitles( string $xmlData, array $pageTitles ) {
 111                 $keys = array_map( static function ( $name ) {
 112                         return "{{{$name}_title}}";
 113                 }, array_keys( $pageTitles ) );
 114
 115                 return str_replace(
 116                         $keys,
 117                         array_values( $pageTitles ),
 118                         $xmlData
 119                 );
 120         }
 121
 122         /**
 123          * @param Title $title
 124          *
 125          * @return RevisionRecord[]
 126          */
 127         private function getRevisions( Title $title ) {
 128                 $store = $this->getServiceContainer()->getRevisionStore();
 129                 $queryBuilder = $store->newSelectQueryBuilder( $this->getDb() )
 130                         ->joinComment()
 131                         ->where( [ 'rev_page' => $title->getArticleID() ] )
 132                         ->orderBy( 'rev_id', SelectQueryBuilder::SORT_ASC );
 133
 134                 $rows = $queryBuilder->caller( __METHOD__ )->fetchResultSet();
 135
 136                 $status = $store->newRevisionsFromBatch( $rows );
 137                 return $status->getValue();
 138         }
 139
 140         /**
 141          * @param string[] $pageTitles
 142          *
 143          * @return string[]
 144          */
 145         private function getPageInfoVars( array $pageTitles ) {
 146                 $vars = [];
 147                 foreach ( $pageTitles as $name => $page ) {
 148                         $title = Title::newFromText( $page );
 149
 150                         if ( !$title->exists( IDBAccessObject::READ_LATEST ) ) {
 151                                 // map only existing pages, since only they can appear in a dump
 152                                 continue;
 153                         }
 154
 155                         $vars[ $name . '_pageid' ] = $title->getArticleID();
 156                         $vars[ $name . '_title' ] = $title->getPrefixedDBkey();
 157                         $vars[ $name . '_namespace' ] = $title->getNamespace();
 158
 159                         $n = 1;
 160                         $revisions = $this->getRevisions( $title );
 161                         foreach ( $revisions as $rev ) {
 162                                 $revkey = "{$name}_rev" . $n++;
 163
 164                                 $vars[ $revkey . '_id' ] = $rev->getId();
 165                                 $vars[ $revkey . '_userid' ] = $rev->getUser()->getId();
 166                         }
 167                 }
 168
 169                 return $vars;
 170         }
 171
 172         /**
 173          * @param string $schemaVersion
 174          * @return string[]
 175          */
 176         private function getSiteVars( $schemaVersion ) {
 177                 global $wgSitename, $wgDBname, $wgCapitalLinks;
 178
 179                 $vars = [];
 180                 $vars['mw_version'] = MW_VERSION;
 181                 $vars['schema_version'] = $schemaVersion;
 182
 183                 $vars['site_name'] = $wgSitename;
 184                 $vars['project_namespace'] =
 185                         $this->getServiceContainer()->getTitleFormatter()->getNamespaceName(
 186                                 NS_PROJECT,
 187                                 'Dummy'
 188                         );
 189                 $vars['site_db'] = $wgDBname;
 190                 $vars['site_case'] = $wgCapitalLinks ? 'first-letter' : 'case-sensitive';
 191                 $vars['site_base'] = Title::newMainPage()->getCanonicalURL();
 192                 $vars['site_language'] = $this->getServiceContainer()->getContentLanguage()->getHtmlCode();
 193
 194                 return $vars;
 195         }
 196
 197         public static function provideImportExport() {
 198                 foreach ( XmlDumpWriter::$supportedSchemas as $schemaVersion ) {
 199                         yield [ 'Basic', $schemaVersion ];
 200                         yield [ 'Dupes', $schemaVersion ];
 201                         yield [ 'Slots', $schemaVersion ];
 202                         yield [ 'Interleaved', $schemaVersion ];
 203                         yield [ 'InterleavedMulti', $schemaVersion ];
 204                         yield [ 'MissingMainContentModel', $schemaVersion ];
 205                         yield [ 'MissingSlotContentModel', $schemaVersion ];
 206                 }
 207         }
 208
 209         /**
 210          * @dataProvider provideImportExport
 211          */
 212         public function testImportExport( $testName, $schemaVersion ) {
 213                 $asserter = new DumpAsserter( $schemaVersion );
 214
 215                 $filesToImport = $this->getFilesToImport( $testName );
 216                 $fileToExpect = $this->getDumpTemplatePath( "$testName.expected", $schemaVersion );
 217                 $siteInfoExpect = $this->getDumpTemplatePath( 'SiteInfo', $schemaVersion );
 218
 219                 $pageKeys = [ 'page1', 'page2', 'page3', 'page4', ];
 220                 $pageTitles = $this->getUniqueNames( $testName, $pageKeys );
 221
 222                 // import each file
 223                 foreach ( $filesToImport as $fileName ) {
 224                         $xmlData = file_get_contents( $fileName );
 225                         $xmlData = $this->injectPageTitles( $xmlData, $pageTitles );
 226
 227                         $source = new ImportStringSource( $xmlData );
 228                         $importer = $this->getImporter( $source );
 229                         $importer->doImport();
 230                 }
 231
 232                 // write dump
 233                 $exporter = $this->getExporter( $schemaVersion );
 234
 235                 $tmpFile = $this->getNewTempFile();
 236                 $buffer = new DumpFileOutput( $tmpFile );
 237
 238                 $exporter->setOutputSink( $buffer );
 239                 $exporter->openStream();
 240                 $exporter->pagesByName( $pageTitles );
 241                 $exporter->closeStream();
 242
 243                 // determine expected variable values
 244                 $vars = array_merge(
 245                         $this->getSiteVars( $schemaVersion ),
 246                         $this->getPageInfoVars( $pageTitles )
 247                 );
 248
 249                 foreach ( $vars as $key => $value ) {
 250                         $asserter->setVarMapping( $key, $value );
 251                 }
 252
 253                 $dumpData = file_get_contents( $tmpFile );
 254                 $this->assertNotEmpty( $dumpData, 'Dump XML' );
 255
 256                 // check dump content
 257                 $asserter->assertDumpStart( $tmpFile, $siteInfoExpect );
 258                 $asserter->assertDOM( $fileToExpect );
 259                 $asserter->assertDumpEnd();
 260         }
 261
 262 }