MediaWiki  master
RevisionStoreTest.php
Go to the documentation of this file.
1 <?php
2 
4 
17 use Title;
23 
28 
29  private function useTextId() {
31 
32  return (bool)( $wgMultiContentRevisionSchemaMigrationStage & SCHEMA_COMPAT_READ_OLD );
33  }
34 
42  private function getRevisionStore(
43  $loadBalancer = null,
44  $blobStore = null,
45  $WANObjectCache = null
46  ) {
48  // the migration stage should be irrelevant, since all the tests that interact with
49  // the database are in RevisionStoreDbTest, not here.
50 
51  return new RevisionStore(
52  $loadBalancer ?: $this->getMockLoadBalancer(),
53  $blobStore ?: $this->getMockSqlBlobStore(),
54  $WANObjectCache ?: $this->getHashWANObjectCache(),
55  MediaWikiServices::getInstance()->getCommentStore(),
56  MediaWikiServices::getInstance()->getContentModelStore(),
57  MediaWikiServices::getInstance()->getSlotRoleStore(),
58  MediaWikiServices::getInstance()->getSlotRoleRegistry(),
59  $wgMultiContentRevisionSchemaMigrationStage,
60  MediaWikiServices::getInstance()->getActorMigration()
61  );
62  }
63 
67  private function getMockLoadBalancer() {
68  return $this->getMockBuilder( LoadBalancer::class )
69  ->disableOriginalConstructor()->getMock();
70  }
71 
75  private function getMockDatabase() {
76  return $this->getMockBuilder( Database::class )
77  ->disableOriginalConstructor()->getMock();
78  }
79 
83  private function getMockSqlBlobStore() {
84  return $this->getMockBuilder( SqlBlobStore::class )
85  ->disableOriginalConstructor()->getMock();
86  }
87 
91  private function getMockCommentStore() {
92  return $this->getMockBuilder( CommentStore::class )
93  ->disableOriginalConstructor()->getMock();
94  }
95 
99  private function getMockSlotRoleRegistry() {
100  return $this->getMockBuilder( SlotRoleRegistry::class )
101  ->disableOriginalConstructor()->getMock();
102  }
103 
104  private function getHashWANObjectCache() {
105  return new WANObjectCache( [ 'cache' => new \HashBagOStuff() ] );
106  }
107 
108  public function provideSetContentHandlerUseDB() {
109  return [
110  // ContentHandlerUseDB can be true of false pre migration.
111  [ false, SCHEMA_COMPAT_OLD, false ],
112  [ true, SCHEMA_COMPAT_OLD, false ],
113  // During and after migration it can not be false...
116  [ false, SCHEMA_COMPAT_NEW, true ],
117  // ...but it can be true.
120  [ true, SCHEMA_COMPAT_NEW, false ],
121  ];
122  }
123 
129  public function testSetContentHandlerUseDB( $contentHandlerDb, $migrationMode, $expectedFail ) {
130  if ( $expectedFail ) {
131  $this->setExpectedException( MWException::class );
132  }
133 
134  $nameTables = MediaWikiServices::getInstance()->getNameTableStoreFactory();
135 
136  $store = new RevisionStore(
137  $this->getMockLoadBalancer(),
138  $this->getMockSqlBlobStore(),
139  $this->getHashWANObjectCache(),
140  $this->getMockCommentStore(),
141  $nameTables->getContentModels(),
142  $nameTables->getSlotRoles(),
143  $this->getMockSlotRoleRegistry(),
144  $migrationMode,
145  MediaWikiServices::getInstance()->getActorMigration()
146  );
147 
148  $store->setContentHandlerUseDB( $contentHandlerDb );
149  $this->assertSame( $contentHandlerDb, $store->getContentHandlerUseDB() );
150  }
151 
155  public function testGetTitle_successFromPageId() {
156  $mockLoadBalancer = $this->getMockLoadBalancer();
157  // Title calls wfGetDB() so we have to set the main service
158  $this->setService( 'DBLoadBalancer', $mockLoadBalancer );
159 
160  $db = $this->getMockDatabase();
161  // Title calls wfGetDB() which uses a regular Connection
162  $mockLoadBalancer->expects( $this->atLeastOnce() )
163  ->method( 'getConnection' )
164  ->willReturn( $db );
165 
166  // First call to Title::newFromID, faking no result (db lag?)
167  $db->expects( $this->at( 0 ) )
168  ->method( 'selectRow' )
169  ->with(
170  'page',
171  $this->anything(),
172  [ 'page_id' => 1 ]
173  )
174  ->willReturn( (object)[
175  'page_namespace' => '1',
176  'page_title' => 'Food',
177  ] );
178 
179  $store = $this->getRevisionStore( $mockLoadBalancer );
180  $title = $store->getTitle( 1, 2, RevisionStore::READ_NORMAL );
181 
182  $this->assertSame( 1, $title->getNamespace() );
183  $this->assertSame( 'Food', $title->getDBkey() );
184  }
185 
190  $mockLoadBalancer = $this->getMockLoadBalancer();
191  // Title calls wfGetDB() so we have to set the main service
192  $this->setService( 'DBLoadBalancer', $mockLoadBalancer );
193 
194  $db = $this->getMockDatabase();
195  // Title calls wfGetDB() which uses a regular Connection
196  // Assert that the first call uses a REPLICA and the second falls back to master
197  $mockLoadBalancer->expects( $this->exactly( 2 ) )
198  ->method( 'getConnection' )
199  ->willReturn( $db );
200  // RevisionStore getTitle uses a ConnectionRef
201  $mockLoadBalancer->expects( $this->atLeastOnce() )
202  ->method( 'getConnectionRef' )
203  ->willReturn( $db );
204 
205  // First call to Title::newFromID, faking no result (db lag?)
206  $db->expects( $this->at( 0 ) )
207  ->method( 'selectRow' )
208  ->with(
209  'page',
210  $this->anything(),
211  [ 'page_id' => 1 ]
212  )
213  ->willReturn( false );
214 
215  // First select using rev_id, faking no result (db lag?)
216  $db->expects( $this->at( 1 ) )
217  ->method( 'selectRow' )
218  ->with(
219  [ 'revision', 'page' ],
220  $this->anything(),
221  [ 'rev_id' => 2 ]
222  )
223  ->willReturn( false );
224 
225  // Second call to Title::newFromID, no result
226  $db->expects( $this->at( 2 ) )
227  ->method( 'selectRow' )
228  ->with(
229  'page',
230  $this->anything(),
231  [ 'page_id' => 1 ]
232  )
233  ->willReturn( (object)[
234  'page_namespace' => '2',
235  'page_title' => 'Foodey',
236  ] );
237 
238  $store = $this->getRevisionStore( $mockLoadBalancer );
239  $title = $store->getTitle( 1, 2, RevisionStore::READ_NORMAL );
240 
241  $this->assertSame( 2, $title->getNamespace() );
242  $this->assertSame( 'Foodey', $title->getDBkey() );
243  }
244 
248  public function testGetTitle_successFromRevId() {
249  $mockLoadBalancer = $this->getMockLoadBalancer();
250  // Title calls wfGetDB() so we have to set the main service
251  $this->setService( 'DBLoadBalancer', $mockLoadBalancer );
252 
253  $db = $this->getMockDatabase();
254  // Title calls wfGetDB() which uses a regular Connection
255  $mockLoadBalancer->expects( $this->atLeastOnce() )
256  ->method( 'getConnection' )
257  ->willReturn( $db );
258  // RevisionStore getTitle uses a ConnectionRef
259  $mockLoadBalancer->expects( $this->atLeastOnce() )
260  ->method( 'getConnectionRef' )
261  ->willReturn( $db );
262 
263  // First call to Title::newFromID, faking no result (db lag?)
264  $db->expects( $this->at( 0 ) )
265  ->method( 'selectRow' )
266  ->with(
267  'page',
268  $this->anything(),
269  [ 'page_id' => 1 ]
270  )
271  ->willReturn( false );
272 
273  // First select using rev_id, faking no result (db lag?)
274  $db->expects( $this->at( 1 ) )
275  ->method( 'selectRow' )
276  ->with(
277  [ 'revision', 'page' ],
278  $this->anything(),
279  [ 'rev_id' => 2 ]
280  )
281  ->willReturn( (object)[
282  'page_namespace' => '1',
283  'page_title' => 'Food2',
284  ] );
285 
286  $store = $this->getRevisionStore( $mockLoadBalancer );
287  $title = $store->getTitle( 1, 2, RevisionStore::READ_NORMAL );
288 
289  $this->assertSame( 1, $title->getNamespace() );
290  $this->assertSame( 'Food2', $title->getDBkey() );
291  }
292 
297  $mockLoadBalancer = $this->getMockLoadBalancer();
298  // Title calls wfGetDB() so we have to set the main service
299  $this->setService( 'DBLoadBalancer', $mockLoadBalancer );
300 
301  $db = $this->getMockDatabase();
302  // Title calls wfGetDB() which uses a regular Connection
303  // Assert that the first call uses a REPLICA and the second falls back to master
304  $mockLoadBalancer->expects( $this->exactly( 2 ) )
305  ->method( 'getConnection' )
306  ->willReturn( $db );
307  // RevisionStore getTitle uses a ConnectionRef
308  $mockLoadBalancer->expects( $this->atLeastOnce() )
309  ->method( 'getConnectionRef' )
310  ->willReturn( $db );
311 
312  // First call to Title::newFromID, faking no result (db lag?)
313  $db->expects( $this->at( 0 ) )
314  ->method( 'selectRow' )
315  ->with(
316  'page',
317  $this->anything(),
318  [ 'page_id' => 1 ]
319  )
320  ->willReturn( false );
321 
322  // First select using rev_id, faking no result (db lag?)
323  $db->expects( $this->at( 1 ) )
324  ->method( 'selectRow' )
325  ->with(
326  [ 'revision', 'page' ],
327  $this->anything(),
328  [ 'rev_id' => 2 ]
329  )
330  ->willReturn( false );
331 
332  // Second call to Title::newFromID, no result
333  $db->expects( $this->at( 2 ) )
334  ->method( 'selectRow' )
335  ->with(
336  'page',
337  $this->anything(),
338  [ 'page_id' => 1 ]
339  )
340  ->willReturn( false );
341 
342  // Second select using rev_id, result
343  $db->expects( $this->at( 3 ) )
344  ->method( 'selectRow' )
345  ->with(
346  [ 'revision', 'page' ],
347  $this->anything(),
348  [ 'rev_id' => 2 ]
349  )
350  ->willReturn( (object)[
351  'page_namespace' => '2',
352  'page_title' => 'Foodey',
353  ] );
354 
355  $store = $this->getRevisionStore( $mockLoadBalancer );
356  $title = $store->getTitle( 1, 2, RevisionStore::READ_NORMAL );
357 
358  $this->assertSame( 2, $title->getNamespace() );
359  $this->assertSame( 'Foodey', $title->getDBkey() );
360  }
361 
366  $mockLoadBalancer = $this->getMockLoadBalancer();
367  // Title calls wfGetDB() so we have to set the main service
368  $this->setService( 'DBLoadBalancer', $mockLoadBalancer );
369 
370  $db = $this->getMockDatabase();
371  // Title calls wfGetDB() which uses a regular Connection
372  // Assert that the first call uses a REPLICA and the second falls back to master
373 
374  // RevisionStore getTitle uses getConnectionRef
375  // Title::newFromID uses getConnection
376  foreach ( [ 'getConnection', 'getConnectionRef' ] as $method ) {
377  $mockLoadBalancer->expects( $this->exactly( 2 ) )
378  ->method( $method )
379  ->willReturnCallback( function ( $masterOrReplica ) use ( $db ) {
380  static $callCounter = 0;
381  $callCounter++;
382  // The first call should be to a REPLICA, and the second a MASTER.
383  if ( $callCounter === 1 ) {
384  $this->assertSame( DB_REPLICA, $masterOrReplica );
385  } elseif ( $callCounter === 2 ) {
386  $this->assertSame( DB_MASTER, $masterOrReplica );
387  }
388  return $db;
389  } );
390  }
391  // First and third call to Title::newFromID, faking no result
392  foreach ( [ 0, 2 ] as $counter ) {
393  $db->expects( $this->at( $counter ) )
394  ->method( 'selectRow' )
395  ->with(
396  'page',
397  $this->anything(),
398  [ 'page_id' => 1 ]
399  )
400  ->willReturn( false );
401  }
402 
403  foreach ( [ 1, 3 ] as $counter ) {
404  $db->expects( $this->at( $counter ) )
405  ->method( 'selectRow' )
406  ->with(
407  [ 'revision', 'page' ],
408  $this->anything(),
409  [ 'rev_id' => 2 ]
410  )
411  ->willReturn( false );
412  }
413 
414  $store = $this->getRevisionStore( $mockLoadBalancer );
415 
416  $this->setExpectedException( RevisionAccessException::class );
417  $store->getTitle( 1, 2, RevisionStore::READ_NORMAL );
418  }
419 
421  yield 'windows-1252, old_flags is empty' => [
422  'windows-1252',
423  'en',
424  [
425  'old_flags' => '',
426  'old_text' => "S\xF6me Content",
427  ],
428  'Söme Content'
429  ];
430 
431  yield 'windows-1252, old_flags is null' => [
432  'windows-1252',
433  'en',
434  [
435  'old_flags' => null,
436  'old_text' => "S\xF6me Content",
437  ],
438  'Söme Content'
439  ];
440  }
441 
447  public function testNewRevisionFromRow_legacyEncoding_applied( $encoding, $locale, $row, $text ) {
448  if ( !$this->useTextId() ) {
449  $this->markTestSkipped( 'No longer applicable with MCR schema' );
450  }
451 
452  $cache = new WANObjectCache( [ 'cache' => new HashBagOStuff() ] );
453  $lb = MediaWikiServices::getInstance()->getDBLoadBalancer();
454 
455  $blobStore = new SqlBlobStore( $lb, $cache );
456  $blobStore->setLegacyEncoding( $encoding, Language::factory( $locale ) );
457 
458  $store = $this->getRevisionStore( $lb, $blobStore, $cache );
459 
460  $record = $store->newRevisionFromRow(
461  $this->makeRow( $row ),
462  0,
463  Title::newFromText( __METHOD__ . '-UTPage' )
464  );
465 
466  $this->assertSame( $text, $record->getContent( SlotRecord::MAIN )->serialize() );
467  }
468 
473  if ( !$this->useTextId() ) {
474  $this->markTestSkipped( 'No longer applicable with MCR schema' );
475  }
476 
477  $row = [
478  'old_flags' => 'utf-8',
479  'old_text' => 'Söme Content',
480  ];
481 
482  $cache = new WANObjectCache( [ 'cache' => new HashBagOStuff() ] );
483  $lb = MediaWikiServices::getInstance()->getDBLoadBalancer();
484 
485  $blobStore = new SqlBlobStore( $lb, $cache );
486  $blobStore->setLegacyEncoding( 'windows-1252', Language::factory( 'en' ) );
487 
488  $store = $this->getRevisionStore( $lb, $blobStore, $cache );
489 
490  $record = $store->newRevisionFromRow(
491  $this->makeRow( $row ),
492  0,
493  Title::newFromText( __METHOD__ . '-UTPage' )
494  );
495  $this->assertSame( 'Söme Content', $record->getContent( SlotRecord::MAIN )->serialize() );
496  }
497 
498  private function makeRow( array $array ) {
499  $row = $array + [
500  'rev_id' => 7,
501  'rev_page' => 5,
502  'rev_timestamp' => '20110101000000',
503  'rev_user_text' => 'Tester',
504  'rev_user' => 17,
505  'rev_minor_edit' => 0,
506  'rev_deleted' => 0,
507  'rev_len' => 100,
508  'rev_parent_id' => 0,
509  'rev_sha1' => 'deadbeef',
510  'rev_comment_text' => 'Testing',
511  'rev_comment_data' => '{}',
512  'rev_comment_cid' => 111,
513  'page_namespace' => 0,
514  'page_title' => 'TEST',
515  'page_id' => 5,
516  'page_latest' => 7,
517  'page_is_redirect' => 0,
518  'page_len' => 100,
519  'user_name' => 'Tester',
520  ];
521 
522  if ( $this->useTextId() ) {
523  $row += [
524  'rev_content_format' => CONTENT_FORMAT_TEXT,
525  'rev_content_model' => CONTENT_MODEL_TEXT,
526  'rev_text_id' => 11,
527  'old_id' => 11,
528  'old_text' => 'Hello World',
529  'old_flags' => 'utf-8',
530  ];
531  } elseif ( !isset( $row['content'] ) && isset( $array['old_text'] ) ) {
532  $row['content'] = [
533  'main' => new WikitextContent( $array['old_text'] ),
534  ];
535  }
536 
537  return (object)$row;
538  }
539 
540  public function provideMigrationConstruction() {
541  return [
549  ];
550  }
551 
556  public function testMigrationConstruction( $migration, $expectException ) {
557  if ( $expectException ) {
558  $this->setExpectedException( InvalidArgumentException::class );
559  }
560  $loadBalancer = $this->getMockLoadBalancer();
561  $blobStore = $this->getMockSqlBlobStore();
562  $cache = $this->getHashWANObjectCache();
563  $commentStore = $this->getMockCommentStore();
565  $nameTables = $services->getNameTableStoreFactory();
566  $contentModelStore = $nameTables->getContentModels();
567  $slotRoleStore = $nameTables->getSlotRoles();
568  $slotRoleRegistry = $services->getSlotRoleRegistry();
569  $store = new RevisionStore(
570  $loadBalancer,
571  $blobStore,
572  $cache,
573  $commentStore,
574  $nameTables->getContentModels(),
575  $nameTables->getSlotRoles(),
576  $slotRoleRegistry,
577  $migration,
578  $services->getActorMigration()
579  );
580  if ( !$expectException ) {
581  $store = TestingAccessWrapper::newFromObject( $store );
582  $this->assertSame( $loadBalancer, $store->loadBalancer );
583  $this->assertSame( $blobStore, $store->blobStore );
584  $this->assertSame( $cache, $store->cache );
585  $this->assertSame( $commentStore, $store->commentStore );
586  $this->assertSame( $contentModelStore, $store->contentModelStore );
587  $this->assertSame( $slotRoleStore, $store->slotRoleStore );
588  $this->assertSame( $migration, $store->mcrMigrationStage );
589  }
590  }
591 
592 }
const SCHEMA_COMPAT_WRITE_OLD
Definition: Defines.php:280
Service for storing and loading Content objects.
testMigrationConstruction( $migration, $expectException)
\MediaWiki\Revision\RevisionStore::__construct provideMigrationConstruction
const SCHEMA_COMPAT_READ_BOTH
Definition: Defines.php:285
processing should stop and the error should be shown to the user * false
Definition: hooks.txt:187
int $wgMultiContentRevisionSchemaMigrationStage
RevisionStore table schema migration stage (content, slots, content_models & slot_roles tables)...
Apache License January AND DISTRIBUTION Definitions License shall mean the terms and conditions for use
testSetContentHandlerUseDB( $contentHandlerDb, $migrationMode, $expectedFail)
provideSetContentHandlerUseDB \MediaWiki\Revision\RevisionStore::getContentHandlerUseDB \MediaWiki\Re...
const SCHEMA_COMPAT_READ_NEW
Definition: Defines.php:283
testGetTitle_successFromRevIdOnFallback()
\MediaWiki\Revision\RevisionStore::getTitle
injection txt This is an overview of how MediaWiki makes use of dependency injection The design described here grew from the discussion of RFC T384 The term dependency this means that anything an object needs to operate should be injected from the the object itself should only know narrow no concrete implementation of the logic it relies on The requirement to inject everything typically results in an architecture that based on two main types of and essentially stateless service objects that use other service objects to operate on the value objects As of the beginning MediaWiki is only starting to use the DI approach Much of the code still relies on global state or direct resulting in a highly cyclical dependency MediaWikiServices
Definition: injection.txt:23
const CONTENT_MODEL_TEXT
Definition: Defines.php:234
static getInstance()
Returns the global default instance of the top level service locator.
const DB_MASTER
Definition: defines.php:26
This document is intended to provide useful advice for parties seeking to redistribute MediaWiki to end users It s targeted particularly at maintainers for Linux since it s been observed that distribution packages of MediaWiki often break We ve consistently had to recommend that users seeking support use official tarballs instead of their distribution s and this often solves whatever problem the user is having It would be nice if this could such and we might be restricted by PHP settings such as safe mode or open_basedir We cannot assume that the software even has read access anywhere useful Many shared hosts run all users web applications under the same so they can t rely on Unix and must forbid reads to even standard directories like tmp lest users read each others files We cannot assume that the user has the ability to install or run any programs not written as web accessible PHP scripts Since anything that works on cheap shared hosting will work if you have shell or root access MediaWiki s design is based around catering to the lowest common denominator Although we support higher end setups as the way many things work by default is tailored toward shared hosting These defaults are unconventional from the point of view of and they certainly aren t ideal for someone who s installing MediaWiki as MediaWiki does not conform to normal Unix filesystem layout Hopefully we ll offer direct support for standard layouts in the but for now *any change to the location of files is unsupported *Moving things and leaving symlinks will *probably *not break anything
getRevisionStore( $loadBalancer=null, $blobStore=null, $WANObjectCache=null)
null means default in associative array with keys and values unescaped Should be merged with default with a value of false meaning to suppress the attribute in associative array with keys and values unescaped noclasses just before the function returns a value If you return true
Definition: hooks.txt:1982
const CONTENT_FORMAT_TEXT
Definition: Defines.php:252
testNewRevisionFromRow_legacyEncoding_applied( $encoding, $locale, $row, $text)
provideNewRevisionFromRow_legacyEncoding_applied
static configuration should be added through ResourceLoaderGetConfigVars instead can be used to get the real title e g db for database replication lag or jobqueue for job queue size converted to pseudo seconds It is possible to add more fields and they will be returned to the user in the API response after the basic globals have been set but before ordinary actions take place or wrap services the preferred way to define a new service is the $wgServiceWiringFiles array $services
Definition: hooks.txt:2217
Service for looking up page revisions.
const SCHEMA_COMPAT_WRITE_NEW
Definition: Defines.php:282
$cache
Definition: mcc.php:33
this hook is for auditing only or null if authentication failed before getting that far or null if we can t even determine that When $user is not null
Definition: hooks.txt:780
namespace and then decline to actually register it file or subcat img or subcat $title
Definition: hooks.txt:925
static factory( $code)
Get a cached or new language object for a given language code.
Definition: Language.php:216
testGetTitle_successFromRevId()
\MediaWiki\Revision\RevisionStore::getTitle
This document is intended to provide useful advice for parties seeking to redistribute MediaWiki to end users It s targeted particularly at maintainers for Linux since it s been observed that distribution packages of MediaWiki often break We ve consistently had to recommend that users seeking support use official tarballs instead of their distribution s and this often solves whatever problem the user is having It would be nice if this could such as
Definition: distributors.txt:9
const SCHEMA_COMPAT_WRITE_BOTH
Definition: Defines.php:284
setService( $name, $object)
Sets a service, maintaining a stashed version of the previous service to be restored in tearDown...
injection txt This is an overview of how MediaWiki makes use of dependency injection The design described here grew from the discussion of RFC T384 The term dependency this means that anything an object needs to operate should be injected from the the object itself should only know narrow no concrete implementation of the logic it relies on The requirement to inject everything typically results in an architecture that based on two main types of and essentially stateless service objects that use other service objects to operate on the value objects As of the beginning MediaWiki is only starting to use the DI approach Much of the code still relies on global state or direct resulting in a highly cyclical dependency which acts as the top level factory for services in MediaWiki which can be used to gain access to default instances of various services MediaWikiServices however also allows new services to be defined and default services to be redefined Services are defined or redefined by providing a callback the instantiator that will return a new instance of the service When it will create an instance of MediaWikiServices and populate it with the services defined in the files listed by thereby bootstrapping the DI framework Per $wgServiceWiringFiles lists includes ServiceWiring php
Definition: injection.txt:35
testGetTitle_successFromPageId()
\MediaWiki\Revision\RevisionStore::getTitle
you have access to all of the normal MediaWiki so you can get a DB use the etc For full docs on the Maintenance class
Definition: maintenance.txt:52
setContentHandlerUseDB( $contentHandlerUseDB)
const SCHEMA_COMPAT_NEW
Definition: Defines.php:287
Database $db
Primary database.
testNewRevisionFromRow_legacyEncoding_ignored()
\MediaWiki\Revision\RevisionStore::newRevisionFromRow
const DB_REPLICA
Definition: defines.php:25
const SCHEMA_COMPAT_READ_OLD
Definition: Defines.php:281
const SCHEMA_COMPAT_OLD
Definition: Defines.php:286
testGetTitle_correctFallbackAndthrowsExceptionAfterFallbacks()
\MediaWiki\Revision\RevisionStore::getTitle
testGetTitle_successFromPageIdOnFallback()
\MediaWiki\Revision\RevisionStore::getTitle
static newFromText( $text, $defaultNamespace=NS_MAIN)
Create a new Title from text, such as what one would find in a link.
Definition: Title.php:319