3 namespace MediaWiki\Tests\Storage
;
5 use CommentStoreComment
;
7 use MediaWiki\MediaWikiServices
;
8 use MediaWiki\Storage\RevisionRecord
;
9 use MediaWiki\Storage\SlotRecord
;
10 use MediaWikiTestCase
;
20 * @covers \MediaWiki\Storage\PageUpdater
23 class PageUpdaterTest
extends MediaWikiTestCase
{
25 private function getDummyTitle( $method ) {
26 return Title
::newFromText( $method, $this->getDefaultWikitextNS() );
32 * @return null|RecentChange
34 private function getRecentChangeFor( $revId ) {
35 $qi = RecentChange
::getQueryInfo();
36 $row = $this->db
->selectRow(
39 [ 'rc_this_oldid' => $revId ],
45 return $row ? RecentChange
::newFromRow( $row ) : null;
48 // TODO: test setAjaxEditStash();
51 * @covers \MediaWiki\Storage\PageUpdater::saveRevision()
52 * @covers \WikiPage::newPageUpdater()
54 public function testCreatePage() {
55 $user = $this->getTestUser()->getUser();
57 $title = $this->getDummyTitle( __METHOD__
);
58 $page = WikiPage
::factory( $title );
59 $updater = $page->newPageUpdater( $user );
61 $oldStats = $this->db
->selectRow( 'site_stats', '*', '1=1' );
63 $this->assertFalse( $updater->wasCommitted(), 'wasCommitted' );
64 $this->assertFalse( $updater->getOriginalRevisionId(), 'getOriginalRevisionId' );
65 $this->assertSame( 0, $updater->getUndidRevisionId(), 'getUndidRevisionId' );
67 $updater->addTag( 'foo' );
68 $updater->addTags( [ 'bar', 'qux' ] );
70 $tags = $updater->getExplicitTags();
72 $this->assertSame( [ 'bar', 'foo', 'qux' ], $tags, 'getExplicitTags' );
74 // TODO: MCR: test additional slots
75 $content = new TextContent( 'Lorem Ipsum' );
76 $updater->setContent( SlotRecord
::MAIN
, $content );
78 $parent = $updater->grabParentRevision();
80 $this->assertNull( $parent, 'getParentRevision' );
81 $this->assertFalse( $updater->wasCommitted(), 'wasCommitted' );
83 // TODO: test that hasEditConflict() grabs the parent revision
84 $this->assertFalse( $updater->hasEditConflict( 0 ), 'hasEditConflict' );
85 $this->assertTrue( $updater->hasEditConflict( 1 ), 'hasEditConflict' );
87 // TODO: test failure with EDIT_UPDATE
88 // TODO: test EDIT_MINOR, EDIT_BOT, etc
89 $summary = CommentStoreComment
::newUnsavedComment( 'Just a test' );
90 $rev = $updater->saveRevision( $summary );
92 $this->assertNotNull( $rev );
93 $this->assertSame( 0, $rev->getParentId() );
94 $this->assertSame( $summary->text
, $rev->getComment( RevisionRecord
::RAW
)->text
);
95 $this->assertSame( $user->getName(), $rev->getUser( RevisionRecord
::RAW
)->getName() );
97 $this->assertTrue( $updater->wasCommitted(), 'wasCommitted()' );
98 $this->assertTrue( $updater->wasSuccessful(), 'wasSuccessful()' );
99 $this->assertTrue( $updater->getStatus()->isOK(), 'getStatus()->isOK()' );
100 $this->assertTrue( $updater->isNew(), 'isNew()' );
101 $this->assertFalse( $updater->isUnchanged(), 'isUnchanged()' );
102 $this->assertNotNull( $updater->getNewRevision(), 'getNewRevision()' );
103 $this->assertInstanceOf( Revision
::class, $updater->getStatus()->value
['revision'] );
105 $rev = $updater->getNewRevision();
106 $revContent = $rev->getContent( SlotRecord
::MAIN
);
107 $this->assertSame( 'Lorem Ipsum', $revContent->serialize(), 'revision content' );
109 // were the WikiPage and Title objects updated?
110 $this->assertTrue( $page->exists(), 'WikiPage::exists()' );
111 $this->assertTrue( $title->exists(), 'Title::exists()' );
112 $this->assertSame( $rev->getId(), $page->getLatest(), 'WikiPage::getRevision()' );
113 $this->assertNotNull( $page->getRevision(), 'WikiPage::getRevision()' );
116 $page2 = WikiPage
::factory( $title );
117 $this->assertTrue( $page2->exists(), 'WikiPage::exists()' );
118 $this->assertSame( $rev->getId(), $page2->getLatest(), 'WikiPage::getRevision()' );
119 $this->assertNotNull( $page2->getRevision(), 'WikiPage::getRevision()' );
122 $rc = $this->getRecentChangeFor( $rev->getId() );
123 $this->assertNotNull( $rc, 'RecentChange' );
125 // check site stats - this asserts that derived data updates where run.
126 $stats = $this->db
->selectRow( 'site_stats', '*', '1=1' );
127 $this->assertSame( $oldStats->ss_total_pages +
1, (int)$stats->ss_total_pages
);
128 $this->assertSame( $oldStats->ss_total_edits +
1, (int)$stats->ss_total_edits
);
130 // re-edit with same content - should be a "null-edit"
131 $updater = $page->newPageUpdater( $user );
132 $updater->setContent( SlotRecord
::MAIN
, $content );
134 $summary = CommentStoreComment
::newUnsavedComment( 'to to re-edit' );
135 $rev = $updater->saveRevision( $summary );
136 $status = $updater->getStatus();
138 $this->assertNull( $rev, 'getNewRevision()' );
139 $this->assertNull( $updater->getNewRevision(), 'getNewRevision()' );
140 $this->assertTrue( $updater->isUnchanged(), 'isUnchanged' );
141 $this->assertTrue( $updater->wasSuccessful(), 'wasSuccessful()' );
142 $this->assertTrue( $status->isOK(), 'getStatus()->isOK()' );
143 $this->assertTrue( $status->hasMessage( 'edit-no-change' ), 'edit-no-change' );
147 * @covers \MediaWiki\Storage\PageUpdater::saveRevision()
148 * @covers \WikiPage::newPageUpdater()
150 public function testUpdatePage() {
151 $user = $this->getTestUser()->getUser();
153 $title = $this->getDummyTitle( __METHOD__
);
154 $this->insertPage( $title );
156 $page = WikiPage
::factory( $title );
157 $parentId = $page->getLatest();
159 $updater = $page->newPageUpdater( $user );
161 $oldStats = $this->db
->selectRow( 'site_stats', '*', '1=1' );
163 $updater->setOriginalRevisionId( 7 );
164 $this->assertSame( 7, $updater->getOriginalRevisionId(), 'getOriginalRevisionId' );
166 $this->assertFalse( $updater->hasEditConflict( $parentId ), 'hasEditConflict' );
167 $this->assertTrue( $updater->hasEditConflict( $parentId - 1 ), 'hasEditConflict' );
168 $this->assertTrue( $updater->hasEditConflict( 0 ), 'hasEditConflict' );
170 // TODO: MCR: test additional slots
171 $updater->setContent( SlotRecord
::MAIN
, new TextContent( 'Lorem Ipsum' ) );
173 // TODO: test all flags for saveRevision()!
174 $summary = CommentStoreComment
::newUnsavedComment( 'Just a test' );
175 $rev = $updater->saveRevision( $summary );
177 $this->assertNotNull( $rev );
178 $this->assertSame( $parentId, $rev->getParentId() );
179 $this->assertSame( $summary->text
, $rev->getComment( RevisionRecord
::RAW
)->text
);
180 $this->assertSame( $user->getName(), $rev->getUser( RevisionRecord
::RAW
)->getName() );
182 $this->assertTrue( $updater->wasCommitted(), 'wasCommitted()' );
183 $this->assertTrue( $updater->wasSuccessful(), 'wasSuccessful()' );
184 $this->assertTrue( $updater->getStatus()->isOK(), 'getStatus()->isOK()' );
185 $this->assertFalse( $updater->isNew(), 'isNew()' );
186 $this->assertNotNull( $updater->getNewRevision(), 'getNewRevision()' );
187 $this->assertInstanceOf( Revision
::class, $updater->getStatus()->value
['revision'] );
188 $this->assertFalse( $updater->isUnchanged(), 'isUnchanged()' );
190 // TODO: Test null revision (with different user): new revision!
192 $rev = $updater->getNewRevision();
193 $revContent = $rev->getContent( SlotRecord
::MAIN
);
194 $this->assertSame( 'Lorem Ipsum', $revContent->serialize(), 'revision content' );
196 // were the WikiPage and Title objects updated?
197 $this->assertTrue( $page->exists(), 'WikiPage::exists()' );
198 $this->assertTrue( $title->exists(), 'Title::exists()' );
199 $this->assertSame( $rev->getId(), $page->getLatest(), 'WikiPage::getRevision()' );
200 $this->assertNotNull( $page->getRevision(), 'WikiPage::getRevision()' );
203 $page2 = WikiPage
::factory( $title );
204 $this->assertTrue( $page2->exists(), 'WikiPage::exists()' );
205 $this->assertSame( $rev->getId(), $page2->getLatest(), 'WikiPage::getRevision()' );
206 $this->assertNotNull( $page2->getRevision(), 'WikiPage::getRevision()' );
209 $rc = $this->getRecentChangeFor( $rev->getId() );
210 $this->assertNotNull( $rc, 'RecentChange' );
213 $updater = $page->newPageUpdater( $user );
214 $updater->setContent( SlotRecord
::MAIN
, new TextContent( 'dolor sit amet' ) );
216 $summary = CommentStoreComment
::newUnsavedComment( 're-edit' );
217 $updater->saveRevision( $summary );
218 $this->assertTrue( $updater->wasSuccessful(), 'wasSuccessful()' );
219 $this->assertTrue( $updater->getStatus()->isOK(), 'getStatus()->isOK()' );
221 // check site stats - this asserts that derived data updates where run.
222 $stats = $this->db
->selectRow( 'site_stats', '*', '1=1' );
223 $this->assertNotNull( $stats, 'site_stats' );
224 $this->assertSame( $oldStats->ss_total_pages +
0, (int)$stats->ss_total_pages
);
225 $this->assertSame( $oldStats->ss_total_edits +
2, (int)$stats->ss_total_edits
);
229 * Creates a revision in the database.
231 * @param WikiPage $page
233 * @param null|string|Content $content
235 * @return RevisionRecord|null
237 private function createRevision( WikiPage
$page, $summary, $content = null ) {
238 $user = $this->getTestUser()->getUser();
239 $comment = CommentStoreComment
::newUnsavedComment( $summary );
241 if ( !$content instanceof Content
) {
242 $content = new TextContent( $content ??
$summary );
245 $updater = $page->newPageUpdater( $user );
246 $updater->setContent( SlotRecord
::MAIN
, $content );
247 $rev = $updater->saveRevision( $comment );
252 * @covers \MediaWiki\Storage\PageUpdater::grabParentRevision()
253 * @covers \MediaWiki\Storage\PageUpdater::saveRevision()
255 public function testCompareAndSwapFailure() {
256 $user = $this->getTestUser()->getUser();
258 $title = $this->getDummyTitle( __METHOD__
);
260 // start editing non-existing page
261 $page = WikiPage
::factory( $title );
262 $updater = $page->newPageUpdater( $user );
263 $updater->grabParentRevision();
265 // create page concurrently
266 $concurrentPage = WikiPage
::factory( $title );
267 $this->createRevision( $concurrentPage, __METHOD__
. '-one' );
269 // try creating the page - should trigger CAS failure.
270 $summary = CommentStoreComment
::newUnsavedComment( 'create?!' );
271 $updater->setContent( SlotRecord
::MAIN
, new TextContent( 'Lorem ipsum' ) );
272 $updater->saveRevision( $summary );
273 $status = $updater->getStatus();
275 $this->assertFalse( $updater->wasSuccessful(), 'wasSuccessful()' );
276 $this->assertNull( $updater->getNewRevision(), 'getNewRevision()' );
277 $this->assertFalse( $status->isOK(), 'getStatus()->isOK()' );
278 $this->assertTrue( $status->hasMessage( 'edit-already-exists' ), 'edit-conflict' );
280 // start editing existing page
281 $page = WikiPage
::factory( $title );
282 $updater = $page->newPageUpdater( $user );
283 $updater->grabParentRevision();
285 // update page concurrently
286 $concurrentPage = WikiPage
::factory( $title );
287 $this->createRevision( $concurrentPage, __METHOD__
. '-two' );
289 // try creating the page - should trigger CAS failure.
290 $summary = CommentStoreComment
::newUnsavedComment( 'edit?!' );
291 $updater->setContent( SlotRecord
::MAIN
, new TextContent( 'dolor sit amet' ) );
292 $updater->saveRevision( $summary );
293 $status = $updater->getStatus();
295 $this->assertFalse( $updater->wasSuccessful(), 'wasSuccessful()' );
296 $this->assertNull( $updater->getNewRevision(), 'getNewRevision()' );
297 $this->assertFalse( $status->isOK(), 'getStatus()->isOK()' );
298 $this->assertTrue( $status->hasMessage( 'edit-conflict' ), 'edit-conflict' );
302 * @covers \MediaWiki\Storage\PageUpdater::saveRevision()
304 public function testFailureOnEditFlags() {
305 $user = $this->getTestUser()->getUser();
307 $title = $this->getDummyTitle( __METHOD__
);
309 // start editing non-existing page
310 $page = WikiPage
::factory( $title );
311 $updater = $page->newPageUpdater( $user );
313 // update with EDIT_UPDATE flag should fail
314 $summary = CommentStoreComment
::newUnsavedComment( 'udpate?!' );
315 $updater->setContent( SlotRecord
::MAIN
, new TextContent( 'Lorem ipsum' ) );
316 $updater->saveRevision( $summary, EDIT_UPDATE
);
317 $status = $updater->getStatus();
319 $this->assertFalse( $updater->wasSuccessful(), 'wasSuccessful()' );
320 $this->assertNull( $updater->getNewRevision(), 'getNewRevision()' );
321 $this->assertFalse( $status->isOK(), 'getStatus()->isOK()' );
322 $this->assertTrue( $status->hasMessage( 'edit-gone-missing' ), 'edit-gone-missing' );
325 $this->createRevision( $page, __METHOD__
);
327 // update with EDIT_NEW flag should fail
328 $summary = CommentStoreComment
::newUnsavedComment( 'create?!' );
329 $updater = $page->newPageUpdater( $user );
330 $updater->setContent( SlotRecord
::MAIN
, new TextContent( 'dolor sit amet' ) );
331 $updater->saveRevision( $summary, EDIT_NEW
);
332 $status = $updater->getStatus();
334 $this->assertFalse( $updater->wasSuccessful(), 'wasSuccessful()' );
335 $this->assertNull( $updater->getNewRevision(), 'getNewRevision()' );
336 $this->assertFalse( $status->isOK(), 'getStatus()->isOK()' );
337 $this->assertTrue( $status->hasMessage( 'edit-already-exists' ), 'edit-already-exists' );
340 public function provideSetRcPatrolStatus( $patrolled ) {
341 yield
[ RecentChange
::PRC_UNPATROLLED
];
342 yield
[ RecentChange
::PRC_AUTOPATROLLED
];
346 * @dataProvider provideSetRcPatrolStatus
347 * @covers \MediaWiki\Storage\PageUpdater::setRcPatrolStatus()
349 public function testSetRcPatrolStatus( $patrolled ) {
350 $revisionStore = MediaWikiServices
::getInstance()->getRevisionStore();
352 $user = $this->getTestUser()->getUser();
354 $title = $this->getDummyTitle( __METHOD__
);
356 $page = WikiPage
::factory( $title );
357 $updater = $page->newPageUpdater( $user );
359 $summary = CommentStoreComment
::newUnsavedComment( 'Lorem ipsum ' . $patrolled );
360 $updater->setContent( SlotRecord
::MAIN
, new TextContent( 'Lorem ipsum ' . $patrolled ) );
361 $updater->setRcPatrolStatus( $patrolled );
362 $rev = $updater->saveRevision( $summary );
364 $rc = $revisionStore->getRecentChange( $rev );
365 $this->assertEquals( $patrolled, $rc->getAttribute( 'rc_patrolled' ) );
369 * @covers \MediaWiki\Storage\PageUpdater::inheritSlot()
370 * @covers \MediaWiki\Storage\PageUpdater::setContent()
372 public function testInheritSlot() {
373 $user = $this->getTestUser()->getUser();
374 $title = $this->getDummyTitle( __METHOD__
);
375 $page = WikiPage
::factory( $title );
377 $updater = $page->newPageUpdater( $user );
378 $summary = CommentStoreComment
::newUnsavedComment( 'one' );
379 $updater->setContent( SlotRecord
::MAIN
, new TextContent( 'Lorem ipsum' ) );
380 $rev1 = $updater->saveRevision( $summary, EDIT_NEW
);
382 $updater = $page->newPageUpdater( $user );
383 $summary = CommentStoreComment
::newUnsavedComment( 'two' );
384 $updater->setContent( SlotRecord
::MAIN
, new TextContent( 'Foo Bar' ) );
385 $rev2 = $updater->saveRevision( $summary, EDIT_UPDATE
);
387 $updater = $page->newPageUpdater( $user );
388 $summary = CommentStoreComment
::newUnsavedComment( 'three' );
389 $updater->inheritSlot( $rev1->getSlot( SlotRecord
::MAIN
) );
390 $rev3 = $updater->saveRevision( $summary, EDIT_UPDATE
);
392 $this->assertNotSame( $rev1->getId(), $rev3->getId() );
393 $this->assertNotSame( $rev2->getId(), $rev3->getId() );
395 $main1 = $rev1->getSlot( SlotRecord
::MAIN
);
396 $main3 = $rev3->getSlot( SlotRecord
::MAIN
);
398 $this->assertNotSame( $main1->getRevision(), $main3->getRevision() );
399 $this->assertSame( $main1->getAddress(), $main3->getAddress() );
400 $this->assertTrue( $main1->getContent()->equals( $main3->getContent() ) );
403 // TODO: MCR: test adding multiple slots, inheriting parent slots, and removing slots.
405 public function testSetUseAutomaticEditSummaries() {
406 $this->setContentLang( 'qqx' );
407 $user = $this->getTestUser()->getUser();
409 $title = $this->getDummyTitle( __METHOD__
);
410 $page = WikiPage
::factory( $title );
412 $updater = $page->newPageUpdater( $user );
413 $updater->setUseAutomaticEditSummaries( true );
414 $updater->setContent( SlotRecord
::MAIN
, new TextContent( 'Lorem Ipsum' ) );
416 // empty comment triggers auto-summary
417 $summary = CommentStoreComment
::newUnsavedComment( '' );
418 $updater->saveRevision( $summary, EDIT_AUTOSUMMARY
);
420 $rev = $updater->getNewRevision();
421 $comment = $rev->getComment( RevisionRecord
::RAW
);
422 $this->assertSame( '(autosumm-new: Lorem Ipsum)', $comment->text
, 'comment text' );
424 // check that this also works when blanking the page
425 $updater = $page->newPageUpdater( $user );
426 $updater->setUseAutomaticEditSummaries( true );
427 $updater->setContent( SlotRecord
::MAIN
, new TextContent( '' ) );
429 $summary = CommentStoreComment
::newUnsavedComment( '' );
430 $updater->saveRevision( $summary, EDIT_AUTOSUMMARY
);
432 $rev = $updater->getNewRevision();
433 $comment = $rev->getComment( RevisionRecord
::RAW
);
434 $this->assertSame( '(autosumm-blank)', $comment->text
, 'comment text' );
436 // check that we can also disable edit-summaries
437 $title2 = $this->getDummyTitle( __METHOD__
. '/2' );
438 $page2 = WikiPage
::factory( $title2 );
440 $updater = $page2->newPageUpdater( $user );
441 $updater->setUseAutomaticEditSummaries( false );
442 $updater->setContent( SlotRecord
::MAIN
, new TextContent( 'Lorem Ipsum' ) );
444 $summary = CommentStoreComment
::newUnsavedComment( '' );
445 $updater->saveRevision( $summary, EDIT_AUTOSUMMARY
);
447 $rev = $updater->getNewRevision();
448 $comment = $rev->getComment( RevisionRecord
::RAW
);
449 $this->assertSame( '', $comment->text
, 'comment text should still be lank' );
451 // check that we don't do auto.summaries without the EDIT_AUTOSUMMARY flag
452 $updater = $page2->newPageUpdater( $user );
453 $updater->setUseAutomaticEditSummaries( true );
454 $updater->setContent( SlotRecord
::MAIN
, new TextContent( '' ) );
456 $summary = CommentStoreComment
::newUnsavedComment( '' );
457 $updater->saveRevision( $summary, 0 );
459 $rev = $updater->getNewRevision();
460 $comment = $rev->getComment( RevisionRecord
::RAW
);
461 $this->assertSame( '', $comment->text
, 'comment text' );
464 public function provideSetUsePageCreationLog() {
465 yield
[ true, [ [ 'create', 'create' ] ] ];
470 * @dataProvider provideSetUsePageCreationLog
473 public function testSetUsePageCreationLog( $use, $expected ) {
474 $user = $this->getTestUser()->getUser();
475 $title = $this->getDummyTitle( __METHOD__
. ( $use ?
'_logged' : '_unlogged' ) );
476 $page = WikiPage
::factory( $title );
478 $updater = $page->newPageUpdater( $user );
479 $updater->setUsePageCreationLog( $use );
480 $summary = CommentStoreComment
::newUnsavedComment( 'cmt' );
481 $updater->setContent( SlotRecord
::MAIN
, new TextContent( 'Lorem Ipsum' ) );
482 $updater->saveRevision( $summary, EDIT_NEW
);
484 $rev = $updater->getNewRevision();
487 [ 'log_type', 'log_action' ],
488 [ 'log_page' => $rev->getPageId() ],
493 public function provideMagicWords() {
495 'Test {{PAGEID}} Test',
496 function ( RevisionRecord
$rev ) {
497 return $rev->getPageId();
501 yield
'REVISIONID' => [
502 'Test {{REVISIONID}} Test',
503 function ( RevisionRecord
$rev ) {
504 return $rev->getId();
508 yield
'REVISIONUSER' => [
509 'Test {{REVISIONUSER}} Test',
510 function ( RevisionRecord
$rev ) {
511 return $rev->getUser()->getName();
515 yield
'REVISIONTIMESTAMP' => [
516 'Test {{REVISIONTIMESTAMP}} Test',
517 function ( RevisionRecord
$rev ) {
518 return $rev->getTimestamp();
522 yield
'subst:REVISIONUSER' => [
523 'Test {{subst:REVISIONUSER}} Test',
524 function ( RevisionRecord
$rev ) {
525 return $rev->getUser()->getName();
530 yield
'subst:PAGENAME' => [
531 'Test {{subst:PAGENAME}} Test',
532 function ( RevisionRecord
$rev ) {
533 return 'PageUpdaterTest::testMagicWords';
540 * @covers \MediaWiki\Storage\PageUpdater::saveRevision()
542 * Integration test for PageUpdater, DerivedPageDataUpdater, RevisionRenderer
543 * and RenderedRevision, that ensures that magic words depending on revision meta-data
544 * are handled correctly. Note that each magic word needs to be tested separately,
545 * to assert correct behavior for each "vary" flag in the ParserOutput.
547 * @dataProvider provideMagicWords
549 public function testMagicWords( $wikitext, $callback, $subst = false ) {
550 $user = User
::newFromName( 'A user for ' . __METHOD__
);
551 $user->addToDatabase();
553 $title = $this->getDummyTitle( __METHOD__
. '-' . $this->getName() );
554 $this->insertPage( $title );
556 $page = WikiPage
::factory( $title );
557 $updater = $page->newPageUpdater( $user );
559 $updater->setContent( SlotRecord
::MAIN
, new \
WikitextContent( $wikitext ) );
561 $summary = CommentStoreComment
::newUnsavedComment( 'Just a test' );
562 $rev = $updater->saveRevision( $summary, EDIT_UPDATE
);
565 $this->fail( $updater->getStatus()->getWikiText() );
568 $expected = strval( $callback( $rev ) );
570 $output = $page->getParserOutput( ParserOptions
::newCanonical( 'canonical' ) );
571 $html = $output->getText();
572 $text = $rev->getContent( SlotRecord
::MAIN
)->serialize();
575 $this->assertContains( $expected, $text, 'In Wikitext' );
578 $this->assertContains( $expected, $html, 'In HTML' );