3 abstract class WikiPageDbTestBase
extends MediaWikiLangTestCase
{
5 private $pagesToDelete;
7 public function __construct( $name = null, array $data = [], $dataName = '' ) {
8 parent
::__construct( $name, $data, $dataName );
10 $this->tablesUsed
= array_merge(
33 protected function setUp() {
35 $this->setMwGlobals( 'wgContentHandlerUseDB', $this->getContentHandlerUseDB() );
36 $this->pagesToDelete
= [];
39 protected function tearDown() {
40 foreach ( $this->pagesToDelete
as $p ) {
41 /* @var $p WikiPage */
45 $p->doDeleteArticle( "testing done." );
47 } catch ( MWException
$ex ) {
54 abstract protected function getContentHandlerUseDB();
57 * @param Title|string $title
58 * @param string|null $model
61 private function newPage( $title, $model = null ) {
62 if ( is_string( $title ) ) {
63 $ns = $this->getDefaultWikitextNS();
64 $title = Title
::newFromText( $title, $ns );
67 $p = new WikiPage( $title );
69 $this->pagesToDelete
[] = $p;
75 * @param string|Title|WikiPage $page
81 protected function createPage( $page, $text, $model = null ) {
82 if ( is_string( $page ) ||
$page instanceof Title
) {
83 $page = $this->newPage( $page, $model );
86 $content = ContentHandler
::makeContent( $text, $page->getTitle(), $model );
87 $page->doEditContent( $content, "testing", EDIT_NEW
);
93 * @covers WikiPage::doEditContent
94 * @covers WikiPage::doModify
95 * @covers WikiPage::doCreate
96 * @covers WikiPage::doEditUpdates
98 public function testDoEditContent() {
99 $this->setMwGlobals( 'wgPageCreationLog', true );
101 $page = $this->newPage( __METHOD__
);
102 $title = $page->getTitle();
104 $content = ContentHandler
::makeContent(
105 "[[Lorem ipsum]] dolor sit amet, consetetur sadipscing elitr, sed diam "
106 . " nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat.",
108 CONTENT_MODEL_WIKITEXT
111 $page->doEditContent( $content, "[[testing]] 1" );
113 $id = $page->getId();
115 // Test page creation logging
118 [ 'log_type', 'log_action' ],
119 [ 'log_page' => $id ],
120 [ [ 'create', 'create' ] ]
123 $this->assertTrue( $title->getArticleID() > 0, "Title object should have new page id" );
124 $this->assertTrue( $id > 0, "WikiPage should have new page id" );
125 $this->assertTrue( $title->exists(), "Title object should indicate that the page now exists" );
126 $this->assertTrue( $page->exists(), "WikiPage object should indicate that the page now exists" );
128 # ------------------------
129 $dbr = wfGetDB( DB_REPLICA
);
130 $res = $dbr->select( 'pagelinks', '*', [ 'pl_from' => $id ] );
131 $n = $res->numRows();
134 $this->assertEquals( 1, $n, 'pagelinks should contain one link from the page' );
136 # ------------------------
137 $page = new WikiPage( $title );
139 $retrieved = $page->getContent();
140 $this->assertTrue( $content->equals( $retrieved ), 'retrieved content doesn\'t equal original' );
142 # ------------------------
143 $content = ContentHandler
::makeContent(
144 "At vero eos et accusam et justo duo [[dolores]] et ea rebum. "
145 . "Stet clita kasd [[gubergren]], no sea takimata sanctus est.",
147 CONTENT_MODEL_WIKITEXT
150 $page->doEditContent( $content, "testing 2" );
152 # ------------------------
153 $page = new WikiPage( $title );
155 $retrieved = $page->getContent();
156 $this->assertTrue( $content->equals( $retrieved ), 'retrieved content doesn\'t equal original' );
158 # ------------------------
159 $dbr = wfGetDB( DB_REPLICA
);
160 $res = $dbr->select( 'pagelinks', '*', [ 'pl_from' => $id ] );
161 $n = $res->numRows();
164 $this->assertEquals( 2, $n, 'pagelinks should contain two links from the page' );
168 * Undeletion is covered in PageArchiveTest::testUndeleteRevisions()
169 * TODO: Revision deletion
171 * @covers WikiPage::doDeleteArticle
172 * @covers WikiPage::doDeleteArticleReal
174 public function testDoDeleteArticle() {
175 $page = $this->createPage(
177 "[[original text]] foo",
178 CONTENT_MODEL_WIKITEXT
180 $id = $page->getId();
182 $page->doDeleteArticle( "testing deletion" );
185 $page->getTitle()->getArticleID() > 0,
186 "Title object should now have page id 0"
188 $this->assertFalse( $page->getId() > 0, "WikiPage should now have page id 0" );
191 "WikiPage::exists should return false after page was deleted"
195 "WikiPage::getContent should return null after page was deleted"
198 $t = Title
::newFromText( $page->getTitle()->getPrefixedText() );
201 "Title::exists should return false after page was deleted"
205 JobQueueGroup
::destroySingletons();
207 $jobs->loadParamsAndArgs( null, [ 'quiet' => true ], null );
210 # ------------------------
211 $dbr = wfGetDB( DB_REPLICA
);
212 $res = $dbr->select( 'pagelinks', '*', [ 'pl_from' => $id ] );
213 $n = $res->numRows();
216 $this->assertEquals( 0, $n, 'pagelinks should contain no more links from the page' );
220 * @covers WikiPage::doDeleteArticleReal
222 public function testDoDeleteArticleReal_user0() {
223 $page = $this->createPage(
225 "[[original text]] foo",
226 CONTENT_MODEL_WIKITEXT
228 $id = $page->getId();
231 $status = $page->doDeleteArticleReal(
232 /* reason */ "testing user 0 deletion",
233 /* suppress */ false,
236 /* errorStack */ $errorStack,
239 $logId = $status->getValue();
240 $actorQuery = ActorMigration
::newMigration()->getJoin( 'log_user' );
242 [ 'logging' ] +
$actorQuery['tables'], /* table */
247 'log_user' => $actorQuery['fields']['log_user'],
248 'log_user_text' => $actorQuery['fields']['log_user_text'],
252 [ 'log_id' => $logId ],
256 'testing user 0 deletion',
259 (string)$page->getTitle()->getNamespace(),
260 $page->getTitle()->getDBkey(),
268 * @covers WikiPage::doDeleteArticleReal
270 public function testDoDeleteArticleReal_userSysop() {
271 $page = $this->createPage(
273 "[[original text]] foo",
274 CONTENT_MODEL_WIKITEXT
276 $id = $page->getId();
278 $user = $this->getTestSysop()->getUser();
280 $status = $page->doDeleteArticleReal(
281 /* reason */ "testing sysop deletion",
282 /* suppress */ false,
285 /* errorStack */ $errorStack,
288 $logId = $status->getValue();
289 $actorQuery = ActorMigration
::newMigration()->getJoin( 'log_user' );
291 [ 'logging' ] +
$actorQuery['tables'], /* table */
296 'log_user' => $actorQuery['fields']['log_user'],
297 'log_user_text' => $actorQuery['fields']['log_user_text'],
301 [ 'log_id' => $logId ],
305 'testing sysop deletion',
306 (string)$user->getId(),
308 (string)$page->getTitle()->getNamespace(),
309 $page->getTitle()->getDBkey(),
317 * TODO: Test more stuff about suppression.
319 * @covers WikiPage::doDeleteArticleReal
321 public function testDoDeleteArticleReal_suppress() {
322 $page = $this->createPage(
324 "[[original text]] foo",
325 CONTENT_MODEL_WIKITEXT
327 $id = $page->getId();
329 $user = $this->getTestSysop()->getUser();
331 $status = $page->doDeleteArticleReal(
332 /* reason */ "testing deletion",
336 /* errorStack */ $errorStack,
339 $logId = $status->getValue();
340 $actorQuery = ActorMigration
::newMigration()->getJoin( 'log_user' );
342 [ 'logging' ] +
$actorQuery['tables'], /* table */
347 'log_user' => $actorQuery['fields']['log_user'],
348 'log_user_text' => $actorQuery['fields']['log_user_text'],
352 [ 'log_id' => $logId ],
357 (string)$user->getId(),
359 (string)$page->getTitle()->getNamespace(),
360 $page->getTitle()->getDBkey(),
367 $page->getContent( Revision
::FOR_PUBLIC
),
368 "WikiPage::getContent should return null after the page was suppressed for general users"
372 $page->getContent( Revision
::FOR_THIS_USER
, null ),
373 "WikiPage::getContent should return null after the page was suppressed for user zero"
377 $page->getContent( Revision
::FOR_THIS_USER
, $user ),
378 "WikiPage::getContent should return null after the page was suppressed even for a sysop"
383 * @covers WikiPage::doDeleteUpdates
385 public function testDoDeleteUpdates() {
386 $page = $this->createPage(
388 "[[original text]] foo",
389 CONTENT_MODEL_WIKITEXT
391 $id = $page->getId();
393 // Similar to MovePage logic
394 wfGetDB( DB_MASTER
)->delete( 'page', [ 'page_id' => $id ], __METHOD__
);
395 $page->doDeleteUpdates( $id );
398 JobQueueGroup
::destroySingletons();
400 $jobs->loadParamsAndArgs( null, [ 'quiet' => true ], null );
403 # ------------------------
404 $dbr = wfGetDB( DB_REPLICA
);
405 $res = $dbr->select( 'pagelinks', '*', [ 'pl_from' => $id ] );
406 $n = $res->numRows();
409 $this->assertEquals( 0, $n, 'pagelinks should contain no more links from the page' );
413 * @covers WikiPage::getRevision
415 public function testGetRevision() {
416 $page = $this->newPage( __METHOD__
);
418 $rev = $page->getRevision();
419 $this->assertNull( $rev );
422 $this->createPage( $page, "some text", CONTENT_MODEL_WIKITEXT
);
424 $rev = $page->getRevision();
426 $this->assertEquals( $page->getLatest(), $rev->getId() );
427 $this->assertEquals( "some text", $rev->getContent()->getNativeData() );
431 * @covers WikiPage::getContent
433 public function testGetContent() {
434 $page = $this->newPage( __METHOD__
);
436 $content = $page->getContent();
437 $this->assertNull( $content );
440 $this->createPage( $page, "some text", CONTENT_MODEL_WIKITEXT
);
442 $content = $page->getContent();
443 $this->assertEquals( "some text", $content->getNativeData() );
447 * @covers WikiPage::exists
449 public function testExists() {
450 $page = $this->newPage( __METHOD__
);
451 $this->assertFalse( $page->exists() );
454 $this->createPage( $page, "some text", CONTENT_MODEL_WIKITEXT
);
455 $this->assertTrue( $page->exists() );
457 $page = new WikiPage( $page->getTitle() );
458 $this->assertTrue( $page->exists() );
461 $page->doDeleteArticle( "done testing" );
462 $this->assertFalse( $page->exists() );
464 $page = new WikiPage( $page->getTitle() );
465 $this->assertFalse( $page->exists() );
468 public function provideHasViewableContent() {
470 [ 'WikiPageTest_testHasViewableContent', false, true ],
471 [ 'Special:WikiPageTest_testHasViewableContent', false ],
472 [ 'MediaWiki:WikiPageTest_testHasViewableContent', false ],
473 [ 'Special:Userlogin', true ],
474 [ 'MediaWiki:help', true ],
479 * @dataProvider provideHasViewableContent
480 * @covers WikiPage::hasViewableContent
482 public function testHasViewableContent( $title, $viewable, $create = false ) {
483 $page = $this->newPage( $title );
484 $this->assertEquals( $viewable, $page->hasViewableContent() );
487 $this->createPage( $page, "some text", CONTENT_MODEL_WIKITEXT
);
488 $this->assertTrue( $page->hasViewableContent() );
490 $page = new WikiPage( $page->getTitle() );
491 $this->assertTrue( $page->hasViewableContent() );
495 public function provideGetRedirectTarget() {
497 [ 'WikiPageTest_testGetRedirectTarget_1', CONTENT_MODEL_WIKITEXT
, "hello world", null ],
499 'WikiPageTest_testGetRedirectTarget_2',
500 CONTENT_MODEL_WIKITEXT
,
501 "#REDIRECT [[hello world]]",
508 * @dataProvider provideGetRedirectTarget
509 * @covers WikiPage::getRedirectTarget
511 public function testGetRedirectTarget( $title, $model, $text, $target ) {
512 $this->setMwGlobals( [
513 'wgCapitalLinks' => true,
516 $page = $this->createPage( $title, $text, $model );
518 # sanity check, because this test seems to fail for no reason for some people.
519 $c = $page->getContent();
520 $this->assertEquals( WikitextContent
::class, get_class( $c ) );
522 # now, test the actual redirect
523 $t = $page->getRedirectTarget();
524 $this->assertEquals( $target, is_null( $t ) ?
null : $t->getPrefixedText() );
528 * @dataProvider provideGetRedirectTarget
529 * @covers WikiPage::isRedirect
531 public function testIsRedirect( $title, $model, $text, $target ) {
532 $page = $this->createPage( $title, $text, $model );
533 $this->assertEquals( !is_null( $target ), $page->isRedirect() );
536 public function provideIsCountable() {
540 [ 'WikiPageTest_testIsCountable',
541 CONTENT_MODEL_WIKITEXT
,
546 [ 'WikiPageTest_testIsCountable',
547 CONTENT_MODEL_WIKITEXT
,
554 [ 'WikiPageTest_testIsCountable',
555 CONTENT_MODEL_WIKITEXT
,
560 [ 'WikiPageTest_testIsCountable',
561 CONTENT_MODEL_WIKITEXT
,
568 [ 'WikiPageTest_testIsCountable',
569 CONTENT_MODEL_WIKITEXT
,
574 [ 'WikiPageTest_testIsCountable',
575 CONTENT_MODEL_WIKITEXT
,
581 // not a content namespace
582 [ 'Talk:WikiPageTest_testIsCountable',
583 CONTENT_MODEL_WIKITEXT
,
588 [ 'Talk:WikiPageTest_testIsCountable',
589 CONTENT_MODEL_WIKITEXT
,
595 // not a content namespace, different model
596 [ 'MediaWiki:WikiPageTest_testIsCountable.js',
602 [ 'MediaWiki:WikiPageTest_testIsCountable.js',
612 * @dataProvider provideIsCountable
613 * @covers WikiPage::isCountable
615 public function testIsCountable( $title, $model, $text, $mode, $expected ) {
616 global $wgContentHandlerUseDB;
618 $this->setMwGlobals( 'wgArticleCountMethod', $mode );
620 $title = Title
::newFromText( $title );
622 if ( !$wgContentHandlerUseDB
624 && ContentHandler
::getDefaultModelFor( $title ) != $model
626 $this->markTestSkipped( "Can not use non-default content model $model for "
627 . $title->getPrefixedDBkey() . " with \$wgContentHandlerUseDB disabled." );
630 $page = $this->createPage( $title, $text, $model );
632 $editInfo = $page->prepareContentForEdit( $page->getContent() );
634 $v = $page->isCountable();
635 $w = $page->isCountable( $editInfo );
640 "isCountable( null ) returned unexpected value " . var_export( $v, true )
641 . " instead of " . var_export( $expected, true )
642 . " in mode `$mode` for text \"$text\""
648 "isCountable( \$editInfo ) returned unexpected value " . var_export( $v, true )
649 . " instead of " . var_export( $expected, true )
650 . " in mode `$mode` for text \"$text\""
654 public function provideGetParserOutput() {
657 CONTENT_MODEL_WIKITEXT
,
659 "<div class=\"mw-parser-output\"><p>hello <i>world</i></p></div>"
666 * @dataProvider provideGetParserOutput
667 * @covers WikiPage::getParserOutput
669 public function testGetParserOutput( $model, $text, $expectedHtml ) {
670 $page = $this->createPage( __METHOD__
, $text, $model );
672 $opt = $page->makeParserOptions( 'canonical' );
673 $po = $page->getParserOutput( $opt );
674 $text = $po->getText();
676 $text = trim( preg_replace( '/<!--.*?-->/sm', '', $text ) ); # strip injected comments
677 $text = preg_replace( '!\s*(</p>|</div>)!sm', '\1', $text ); # don't let tidy confuse us
679 $this->assertEquals( $expectedHtml, $text );
685 * @covers WikiPage::getParserOutput
687 public function testGetParserOutput_nonexisting() {
688 $page = new WikiPage( Title
::newFromText( __METHOD__
) );
690 $opt = new ParserOptions();
691 $po = $page->getParserOutput( $opt );
693 $this->assertFalse( $po, "getParserOutput() shall return false for non-existing pages." );
697 * @covers WikiPage::getParserOutput
699 public function testGetParserOutput_badrev() {
700 $page = $this->createPage( __METHOD__
, 'dummy', CONTENT_MODEL_WIKITEXT
);
702 $opt = new ParserOptions();
703 $po = $page->getParserOutput( $opt, $page->getLatest() +
1234 );
705 // @todo would be neat to also test deleted revision
707 $this->assertFalse( $po, "getParserOutput() shall return false for non-existing revisions." );
710 public static $sections =
724 public function dataReplaceSection() {
725 // NOTE: assume the Help namespace to contain wikitext
727 [ 'Help:WikiPageTest_testReplaceSection',
728 CONTENT_MODEL_WIKITEXT
,
733 trim( preg_replace( '/^Intro/sm', 'No more', self
::$sections ) )
735 [ 'Help:WikiPageTest_testReplaceSection',
736 CONTENT_MODEL_WIKITEXT
,
743 [ 'Help:WikiPageTest_testReplaceSection',
744 CONTENT_MODEL_WIKITEXT
,
747 "== TEST ==\nmore fun",
749 trim( preg_replace( '/^== test ==.*== foo ==/sm',
750 "== TEST ==\nmore fun\n\n== foo ==",
753 [ 'Help:WikiPageTest_testReplaceSection',
754 CONTENT_MODEL_WIKITEXT
,
759 trim( self
::$sections )
761 [ 'Help:WikiPageTest_testReplaceSection',
762 CONTENT_MODEL_WIKITEXT
,
767 trim( self
::$sections ) . "\n\n== New ==\n\nNo more"
773 * @dataProvider dataReplaceSection
774 * @covers WikiPage::replaceSectionContent
776 public function testReplaceSectionContent( $title, $model, $text, $section,
777 $with, $sectionTitle, $expected
779 $page = $this->createPage( $title, $text, $model );
781 $content = ContentHandler
::makeContent( $with, $page->getTitle(), $page->getContentModel() );
782 $c = $page->replaceSectionContent( $section, $content, $sectionTitle );
784 $this->assertEquals( $expected, is_null( $c ) ?
null : trim( $c->getNativeData() ) );
788 * @dataProvider dataReplaceSection
789 * @covers WikiPage::replaceSectionAtRev
791 public function testReplaceSectionAtRev( $title, $model, $text, $section,
792 $with, $sectionTitle, $expected
794 $page = $this->createPage( $title, $text, $model );
795 $baseRevId = $page->getLatest();
797 $content = ContentHandler
::makeContent( $with, $page->getTitle(), $page->getContentModel() );
798 $c = $page->replaceSectionAtRev( $section, $content, $sectionTitle, $baseRevId );
800 $this->assertEquals( $expected, is_null( $c ) ?
null : trim( $c->getNativeData() ) );
804 * @covers WikiPage::getOldestRevision
806 public function testGetOldestRevision() {
807 $page = $this->newPage( __METHOD__
);
808 $page->doEditContent(
809 new WikitextContent( 'one' ),
813 $rev1 = $page->getRevision();
815 $page = new WikiPage( $page->getTitle() );
816 $page->doEditContent(
817 new WikitextContent( 'two' ),
822 $page = new WikiPage( $page->getTitle() );
823 $page->doEditContent(
824 new WikitextContent( 'three' ),
830 $this->assertNotEquals(
832 $page->getRevision()->getId(),
833 '$page->getRevision()->getId()'
839 $page->getOldestRevision()->getId(),
840 '$page->getOldestRevision()->getId()'
845 * @covers WikiPage::doRollback
846 * @covers WikiPage::commitRollback
848 public function testDoRollback() {
849 $admin = $this->getTestSysop()->getUser();
850 $user1 = $this->getTestUser()->getUser();
851 // Use the confirmed group for user2 to make sure the user is different
852 $user2 = $this->getTestUser( [ 'confirmed' ] )->getUser();
854 $page = $this->newPage( __METHOD__
);
858 $status1 = $page->doEditContent( ContentHandler
::makeContent( $text, $page->getTitle() ),
859 "section one", EDIT_NEW
, false, $admin );
862 $status2 = $page->doEditContent( ContentHandler
::makeContent( $text, $page->getTitle() ),
863 "adding section two", 0, false, $user1 );
865 $text .= "\n\nthree";
866 $status3 = $page->doEditContent( ContentHandler
::makeContent( $text, $page->getTitle() ),
867 "adding section three", 0, false, $user2 );
869 /** @var Revision $rev1 */
870 /** @var Revision $rev2 */
871 /** @var Revision $rev3 */
872 $rev1 = $status1->getValue()['revision'];
873 $rev2 = $status2->getValue()['revision'];
874 $rev3 = $status3->getValue()['revision'];
877 * We are having issues with doRollback spuriously failing. Apparently
878 * the last revision somehow goes missing or not committed under some
879 * circumstances. So, make sure the revisions have the correct usernames.
881 $this->assertEquals( 3, Revision
::countByPageId( wfGetDB( DB_REPLICA
), $page->getId() ) );
882 $this->assertEquals( $admin->getName(), $rev1->getUserText() );
883 $this->assertEquals( $user1->getName(), $rev2->getUserText() );
884 $this->assertEquals( $user2->getName(), $rev3->getUserText() );
886 // Now, try the actual rollback
887 $token = $admin->getEditToken( 'rollback' );
888 $rollbackErrors = $page->doRollback(
897 if ( $rollbackErrors ) {
899 "Rollback failed:\n" .
900 print_r( $rollbackErrors, true ) . ";\n" .
901 print_r( $resultDetails, true )
905 $page = new WikiPage( $page->getTitle() );
906 $this->assertEquals( $rev2->getSha1(), $page->getRevision()->getSha1(),
907 "rollback did not revert to the correct revision" );
908 $this->assertEquals( "one\n\ntwo", $page->getContent()->getNativeData() );
912 * @covers WikiPage::doRollback
913 * @covers WikiPage::commitRollback
915 public function testDoRollback_simple() {
916 $admin = $this->getTestSysop()->getUser();
919 $page = $this->newPage( __METHOD__
);
920 $page->doEditContent(
921 ContentHandler
::makeContent( $text, $page->getTitle(), CONTENT_MODEL_WIKITEXT
),
927 $rev1 = $page->getRevision();
929 $user1 = $this->getTestUser()->getUser();
931 $page = new WikiPage( $page->getTitle() );
932 $page->doEditContent(
933 ContentHandler
::makeContent( $text, $page->getTitle(), CONTENT_MODEL_WIKITEXT
),
934 "adding section two",
940 # now, try the rollback
941 $token = $admin->getEditToken( 'rollback' );
942 $errors = $page->doRollback(
952 $this->fail( "Rollback failed:\n" . print_r( $errors, true )
953 . ";\n" . print_r( $details, true ) );
956 $page = new WikiPage( $page->getTitle() );
957 $this->assertEquals( $rev1->getSha1(), $page->getRevision()->getSha1(),
958 "rollback did not revert to the correct revision" );
959 $this->assertEquals( "one", $page->getContent()->getNativeData() );
963 * @covers WikiPage::doRollback
964 * @covers WikiPage::commitRollback
966 public function testDoRollbackFailureSameContent() {
967 $admin = $this->getTestSysop()->getUser();
970 $page = $this->newPage( __METHOD__
);
971 $page->doEditContent(
972 ContentHandler
::makeContent( $text, $page->getTitle(), CONTENT_MODEL_WIKITEXT
),
978 $rev1 = $page->getRevision();
980 $user1 = $this->getTestUser( [ 'sysop' ] )->getUser();
982 $page = new WikiPage( $page->getTitle() );
983 $page->doEditContent(
984 ContentHandler
::makeContent( $text, $page->getTitle(), CONTENT_MODEL_WIKITEXT
),
985 "adding section two",
991 # now, do a the rollback from the same user was doing the edit before
993 $token = $user1->getEditToken( 'rollback' );
994 $errors = $page->doRollback(
996 "testing revert same user",
1003 $this->assertEquals( [], $errors, "Rollback failed same user" );
1005 # now, try the rollback
1006 $resultDetails = [];
1007 $token = $admin->getEditToken( 'rollback' );
1008 $errors = $page->doRollback(
1017 $this->assertEquals(
1027 "Rollback not failed"
1030 $page = new WikiPage( $page->getTitle() );
1031 $this->assertEquals( $rev1->getSha1(), $page->getRevision()->getSha1(),
1032 "rollback did not revert to the correct revision" );
1033 $this->assertEquals( "one", $page->getContent()->getNativeData() );
1037 * Tests tagging for edits that do rollback action
1038 * @covers WikiPage::doRollback
1040 public function testDoRollbackTagging() {
1041 if ( !in_array( 'mw-rollback', ChangeTags
::getSoftwareTags() ) ) {
1042 $this->markTestSkipped( 'Rollback tag deactivated, skipped the test.' );
1045 $admin = new User();
1046 $admin->setName( 'Administrator' );
1047 $admin->addToDatabase();
1049 $text = 'First line';
1050 $page = $this->newPage( 'WikiPageTest_testDoRollbackTagging' );
1051 $page->doEditContent(
1052 ContentHandler
::makeContent( $text, $page->getTitle(), CONTENT_MODEL_WIKITEXT
),
1059 $secondUser = new User();
1060 $secondUser->setName( '92.65.217.32' );
1061 $text .= '\n\nSecond line';
1062 $page = new WikiPage( $page->getTitle() );
1063 $page->doEditContent(
1064 ContentHandler
::makeContent( $text, $page->getTitle(), CONTENT_MODEL_WIKITEXT
),
1065 'Adding second line',
1071 // Now, try the rollback
1072 $admin->addGroup( 'sysop' ); // Make the test user a sysop
1073 $token = $admin->getEditToken( 'rollback' );
1074 $errors = $page->doRollback(
1075 $secondUser->getName(),
1083 // If doRollback completed without errors
1084 if ( $errors === [] ) {
1085 $tags = $resultDetails[ 'tags' ];
1086 $this->assertContains( 'mw-rollback', $tags );
1090 public function provideGetAutoDeleteReason() {
1100 [ "first edit", null ],
1102 "/first edit.*only contributor/",
1108 [ "first edit", null ],
1109 [ "second edit", null ],
1111 "/second edit.*only contributor/",
1117 [ "first edit", "127.0.2.22" ],
1118 [ "second edit", "127.0.3.33" ],
1128 . "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam "
1129 . " nonumy eirmod tempor invidunt ut labore et dolore magna "
1130 . "aliquyam erat, sed diam voluptua. At vero eos et accusam "
1131 . "et justo duo dolores et ea rebum. Stet clita kasd gubergren, "
1132 . "no sea takimata sanctus est Lorem ipsum dolor sit amet.'",
1136 '/first edit:.*\.\.\."/',
1142 [ "first edit", "127.0.2.22" ],
1143 [ "", "127.0.3.33" ],
1145 "/before blanking.*first edit/",
1153 * @dataProvider provideGetAutoDeleteReason
1154 * @covers WikiPage::getAutoDeleteReason
1156 public function testGetAutoDeleteReason( $edits, $expectedResult, $expectedHistory ) {
1159 // NOTE: assume Help namespace to contain wikitext
1160 $page = $this->newPage( "Help:WikiPageTest_testGetAutoDeleteReason" );
1164 foreach ( $edits as $edit ) {
1167 if ( !empty( $edit[1] ) ) {
1168 $user->setName( $edit[1] );
1173 $content = ContentHandler
::makeContent( $edit[0], $page->getTitle(), $page->getContentModel() );
1175 $page->doEditContent( $content, "test edit $c", $c < 2 ? EDIT_NEW
: 0, false, $user );
1180 $reason = $page->getAutoDeleteReason( $hasHistory );
1182 if ( is_bool( $expectedResult ) ||
is_null( $expectedResult ) ) {
1183 $this->assertEquals( $expectedResult, $reason );
1185 $this->assertTrue( (bool)preg_match( $expectedResult, $reason ),
1186 "Autosummary didn't match expected pattern $expectedResult: $reason" );
1189 $this->assertEquals( $expectedHistory, $hasHistory,
1190 "expected \$hasHistory to be " . var_export( $expectedHistory, true ) );
1192 $page->doDeleteArticle( "done" );
1195 public function providePreSaveTransform() {
1197 [ 'hello this is ~~~',
1198 "hello this is [[Special:Contributions/127.0.0.1|127.0.0.1]]",
1200 [ 'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
1201 'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
1207 * @covers WikiPage::factory
1209 public function testWikiPageFactory() {
1210 $title = Title
::makeTitle( NS_FILE
, 'Someimage.png' );
1211 $page = WikiPage
::factory( $title );
1212 $this->assertEquals( WikiFilePage
::class, get_class( $page ) );
1214 $title = Title
::makeTitle( NS_CATEGORY
, 'SomeCategory' );
1215 $page = WikiPage
::factory( $title );
1216 $this->assertEquals( WikiCategoryPage
::class, get_class( $page ) );
1218 $title = Title
::makeTitle( NS_MAIN
, 'SomePage' );
1219 $page = WikiPage
::factory( $title );
1220 $this->assertEquals( WikiPage
::class, get_class( $page ) );
1224 * @dataProvider provideCommentMigrationOnDeletion
1226 * @param int $writeStage
1227 * @param int $readStage
1229 public function testCommentMigrationOnDeletion( $writeStage, $readStage ) {
1230 $this->setMwGlobals( 'wgCommentTableSchemaMigrationStage', $writeStage );
1231 $this->overrideMwServices();
1233 $dbr = wfGetDB( DB_REPLICA
);
1235 $page = $this->createPage(
1238 CONTENT_MODEL_WIKITEXT
1240 $revid = $page->getLatest();
1241 if ( $writeStage > MIGRATION_OLD
) {
1242 $comment_id = $dbr->selectField(
1243 'revision_comment_temp',
1244 'revcomment_comment_id',
1245 [ 'revcomment_rev' => $revid ],
1250 $this->setMwGlobals( 'wgCommentTableSchemaMigrationStage', $readStage );
1251 $this->overrideMwServices();
1253 $page->doDeleteArticle( "testing deletion" );
1255 if ( $readStage > MIGRATION_OLD
) {
1256 // Didn't leave behind any 'revision_comment_temp' rows
1257 $n = $dbr->selectField(
1258 'revision_comment_temp', 'COUNT(*)', [ 'revcomment_rev' => $revid ], __METHOD__
1260 $this->assertEquals( 0, $n, 'no entry in revision_comment_temp after deletion' );
1262 // Copied or upgraded the comment_id, as applicable
1263 $ar_comment_id = $dbr->selectField(
1266 [ 'ar_rev_id' => $revid ],
1269 if ( $writeStage > MIGRATION_OLD
) {
1270 $this->assertSame( $comment_id, $ar_comment_id );
1272 $this->assertNotEquals( 0, $ar_comment_id );
1276 // Copied rev_comment, if applicable
1277 if ( $readStage <= MIGRATION_WRITE_BOTH
&& $writeStage <= MIGRATION_WRITE_BOTH
) {
1278 $ar_comment = $dbr->selectField(
1281 [ 'ar_rev_id' => $revid ],
1284 $this->assertSame( 'testing', $ar_comment );
1288 public function provideCommentMigrationOnDeletion() {
1290 [ MIGRATION_OLD
, MIGRATION_OLD
],
1291 [ MIGRATION_OLD
, MIGRATION_WRITE_BOTH
],
1292 [ MIGRATION_OLD
, MIGRATION_WRITE_NEW
],
1293 [ MIGRATION_WRITE_BOTH
, MIGRATION_OLD
],
1294 [ MIGRATION_WRITE_BOTH
, MIGRATION_WRITE_BOTH
],
1295 [ MIGRATION_WRITE_BOTH
, MIGRATION_WRITE_NEW
],
1296 [ MIGRATION_WRITE_BOTH
, MIGRATION_NEW
],
1297 [ MIGRATION_WRITE_NEW
, MIGRATION_WRITE_BOTH
],
1298 [ MIGRATION_WRITE_NEW
, MIGRATION_WRITE_NEW
],
1299 [ MIGRATION_WRITE_NEW
, MIGRATION_NEW
],
1300 [ MIGRATION_NEW
, MIGRATION_WRITE_BOTH
],
1301 [ MIGRATION_NEW
, MIGRATION_WRITE_NEW
],
1302 [ MIGRATION_NEW
, MIGRATION_NEW
],
1307 * @covers WikiPage::updateCategoryCounts
1309 public function testUpdateCategoryCounts() {
1310 $page = new WikiPage( Title
::newFromText( __METHOD__
) );
1312 // Add an initial category
1313 $page->updateCategoryCounts( [ 'A' ], [], 0 );
1315 $this->assertEquals( 1, Category
::newFromName( 'A' )->getPageCount() );
1316 $this->assertEquals( 0, Category
::newFromName( 'B' )->getPageCount() );
1317 $this->assertEquals( 0, Category
::newFromName( 'C' )->getPageCount() );
1319 // Add a new category
1320 $page->updateCategoryCounts( [ 'B' ], [], 0 );
1322 $this->assertEquals( 1, Category
::newFromName( 'A' )->getPageCount() );
1323 $this->assertEquals( 1, Category
::newFromName( 'B' )->getPageCount() );
1324 $this->assertEquals( 0, Category
::newFromName( 'C' )->getPageCount() );
1326 // Add and remove a category
1327 $page->updateCategoryCounts( [ 'C' ], [ 'A' ], 0 );
1329 $this->assertEquals( 0, Category
::newFromName( 'A' )->getPageCount() );
1330 $this->assertEquals( 1, Category
::newFromName( 'B' )->getPageCount() );
1331 $this->assertEquals( 1, Category
::newFromName( 'C' )->getPageCount() );
1334 public function provideUpdateRedirectOn() {
1335 yield
[ '#REDIRECT [[Foo]]', true, null, true, true, 0 ];
1336 yield
[ '#REDIRECT [[Foo]]', true, 'Foo', true, false, 1 ];
1337 yield
[ 'SomeText', false, null, false, true, 0 ];
1338 yield
[ 'SomeText', false, 'Foo', false, false, 1 ];
1342 * @dataProvider provideUpdateRedirectOn
1343 * @covers WikiPage::updateRedirectOn
1345 * @param string $initialText
1346 * @param bool $initialRedirectState
1347 * @param string|null $redirectTitle
1348 * @param bool|null $lastRevIsRedirect
1349 * @param bool $expectedSuccess
1350 * @param int $expectedRowCount
1352 public function testUpdateRedirectOn(
1354 $initialRedirectState,
1360 static $pageCounter = 0;
1363 $page = $this->createPage( Title
::newFromText( __METHOD__
. $pageCounter ), $initialText );
1364 $this->assertSame( $initialRedirectState, $page->isRedirect() );
1366 $redirectTitle = is_string( $redirectTitle )
1367 ? Title
::newFromText( $redirectTitle )
1370 $success = $page->updateRedirectOn( $this->db
, $redirectTitle, $lastRevIsRedirect );
1371 $this->assertSame( $expectedSuccess, $success, 'Success assertion' );
1373 * updateRedirectOn explicitly updates the redirect table (and not the page table).
1374 * Most of core checks the page table for redirect status, so we have to be ugly and
1375 * assert a select from the table here.
1377 $this->assertRedirectTableCountForPageId( $page->getId(), $expectedRowCount );
1380 private function assertRedirectTableCountForPageId( $pageId, $expected ) {
1381 $this->assertSelect(
1384 [ 'rd_from' => $pageId ],
1385 [ [ strval( $expected ) ] ]
1390 * @covers WikiPage::insertRedirectEntry
1392 public function testInsertRedirectEntry_insertsRedirectEntry() {
1393 $page = $this->createPage( Title
::newFromText( __METHOD__
), 'A' );
1394 $this->assertRedirectTableCountForPageId( $page->getId(), 0 );
1396 $targetTitle = Title
::newFromText( 'SomeTarget#Frag' );
1397 $targetTitle->mInterwiki
= 'eninter';
1398 $page->insertRedirectEntry( $targetTitle, null );
1400 $this->assertSelect(
1402 [ 'rd_from', 'rd_namespace', 'rd_title', 'rd_fragment', 'rd_interwiki' ],
1403 [ 'rd_from' => $page->getId() ],
1405 strval( $page->getId() ),
1406 strval( $targetTitle->getNamespace() ),
1407 strval( $targetTitle->getDBkey() ),
1408 strval( $targetTitle->getFragment() ),
1409 strval( $targetTitle->getInterwiki() ),
1415 * @covers WikiPage::insertRedirectEntry
1417 public function testInsertRedirectEntry_insertsRedirectEntryWithPageLatest() {
1418 $page = $this->createPage( Title
::newFromText( __METHOD__
), 'A' );
1419 $this->assertRedirectTableCountForPageId( $page->getId(), 0 );
1421 $targetTitle = Title
::newFromText( 'SomeTarget#Frag' );
1422 $targetTitle->mInterwiki
= 'eninter';
1423 $page->insertRedirectEntry( $targetTitle, $page->getLatest() );
1425 $this->assertSelect(
1427 [ 'rd_from', 'rd_namespace', 'rd_title', 'rd_fragment', 'rd_interwiki' ],
1428 [ 'rd_from' => $page->getId() ],
1430 strval( $page->getId() ),
1431 strval( $targetTitle->getNamespace() ),
1432 strval( $targetTitle->getDBkey() ),
1433 strval( $targetTitle->getFragment() ),
1434 strval( $targetTitle->getInterwiki() ),
1440 * @covers WikiPage::insertRedirectEntry
1442 public function testInsertRedirectEntry_doesNotInsertIfPageLatestIncorrect() {
1443 $page = $this->createPage( Title
::newFromText( __METHOD__
), 'A' );
1444 $this->assertRedirectTableCountForPageId( $page->getId(), 0 );
1446 $targetTitle = Title
::newFromText( 'SomeTarget#Frag' );
1447 $targetTitle->mInterwiki
= 'eninter';
1448 $page->insertRedirectEntry( $targetTitle, 215251 );
1450 $this->assertRedirectTableCountForPageId( $page->getId(), 0 );
1453 private function getRow( array $overrides = [] ) {
1457 'page_is_redirect' => '1',
1458 'page_latest' => '99',
1459 'page_namespace' => '3',
1460 'page_title' => 'JaJaTitle',
1461 'page_restrictions' => 'edit=autoconfirmed,sysop:move=sysop',
1462 'page_touched' => '20120101020202',
1463 'page_links_updated' => '20140101020202',
1465 foreach ( $overrides as $key => $value ) {
1466 $row[$key] = $value;
1468 return (object)$row;
1471 public function provideNewFromRowSuccess() {
1472 yield
'basic row' => [
1474 function ( WikiPage
$wikiPage, self
$test ) {
1475 $test->assertSame( 44, $wikiPage->getId() );
1476 $test->assertSame( 76, $wikiPage->getTitle()->getLength() );
1477 $test->assertTrue( $wikiPage->isRedirect() );
1478 $test->assertSame( 99, $wikiPage->getLatest() );
1479 $test->assertSame( 3, $wikiPage->getTitle()->getNamespace() );
1480 $test->assertSame( 'JaJaTitle', $wikiPage->getTitle()->getDBkey() );
1483 'edit' => [ 'autoconfirmed', 'sysop' ],
1484 'move' => [ 'sysop' ],
1486 $wikiPage->getTitle()->getAllRestrictions()
1488 $test->assertSame( '20120101020202', $wikiPage->getTouched() );
1489 $test->assertSame( '20140101020202', $wikiPage->getLinksTimestamp() );
1492 yield
'different timestamp formats' => [
1494 'page_touched' => '2012-01-01 02:02:02',
1495 'page_links_updated' => '2014-01-01 02:02:02',
1497 function ( WikiPage
$wikiPage, self
$test ) {
1498 $test->assertSame( '20120101020202', $wikiPage->getTouched() );
1499 $test->assertSame( '20140101020202', $wikiPage->getLinksTimestamp() );
1502 yield
'no restrictions' => [
1504 'page_restrictions' => '',
1506 function ( WikiPage
$wikiPage, self
$test ) {
1512 $wikiPage->getTitle()->getAllRestrictions()
1516 yield
'not redirect' => [
1518 'page_is_redirect' => '0',
1520 function ( WikiPage
$wikiPage, self
$test ) {
1521 $test->assertFalse( $wikiPage->isRedirect() );
1527 * @covers WikiPage::newFromRow
1528 * @covers WikiPage::loadFromRow
1529 * @dataProvider provideNewFromRowSuccess
1531 * @param object $row
1532 * @param callable $assertions
1534 public function testNewFromRow( $row, $assertions ) {
1535 $page = WikiPage
::newFromRow( $row, 'fromdb' );
1536 $assertions( $page, $this );
1539 public function provideTestNewFromId_returnsNullOnBadPageId() {
1545 * @covers WikiPage::newFromID
1546 * @dataProvider provideTestNewFromId_returnsNullOnBadPageId
1548 public function testNewFromId_returnsNullOnBadPageId( $pageId ) {
1549 $this->assertNull( WikiPage
::newFromID( $pageId ) );
1553 * @covers WikiPage::newFromID
1555 public function testNewFromId_appearsToFetchCorrectRow() {
1556 $createdPage = $this->createPage( __METHOD__
, 'Xsfaij09' );
1557 $fetchedPage = WikiPage
::newFromID( $createdPage->getId() );
1558 $this->assertSame( $createdPage->getId(), $fetchedPage->getId() );
1559 $this->assertEquals(
1560 $createdPage->getContent()->getNativeData(),
1561 $fetchedPage->getContent()->getNativeData()
1566 * @covers WikiPage::newFromID
1568 public function testNewFromId_returnsNullOnNonExistingId() {
1569 $this->assertNull( WikiPage
::newFromID( 2147483647 ) );
1572 public function provideTestInsertProtectNullRevision() {
1573 // phpcs:disable Generic.Files.LineLength
1576 [ 'edit' => 'sysop' ],
1577 [ 'edit' => '20200101040404' ],
1581 '(goat-message-key: WikiPageDbTestBase::testInsertProtectNullRevision, UTSysop)(colon-separator)Goat Reason(word-separator)(parentheses: (protect-summary-desc: (restriction-edit), (protect-level-sysop), (protect-expiring: 04:04, 1 (january) 2020, 1 (january) 2020, 04:04)))'
1585 [ 'edit' => 'sysop', 'move' => 'something' ],
1586 [ 'edit' => '20200101040404', 'move' => '20210101050505' ],
1590 '(goat-key: WikiPageDbTestBase::testInsertProtectNullRevision, UTSysop)(colon-separator)Goat Goat(word-separator)(parentheses: (protect-summary-desc: (restriction-edit), (protect-level-sysop), (protect-expiring: 04:04, 1 (january) 2020, 1 (january) 2020, 04:04))(word-separator)(protect-summary-desc: (restriction-move), (protect-level-something), (protect-expiring: 05:05, 1 (january) 2021, 1 (january) 2021, 05:05)))'
1596 * @dataProvider provideTestInsertProtectNullRevision
1597 * @covers WikiPage::insertProtectNullRevision
1598 * @covers WikiPage::protectDescription
1600 * @param string $revCommentMsg
1601 * @param array $limit
1602 * @param array $expiry
1603 * @param bool $cascade
1604 * @param string $reason
1605 * @param bool|null $user true if the test sysop should be used, or null
1606 * @param string $expectedComment
1608 public function testInsertProtectNullRevision(
1617 $this->setContentLang( 'qqx' );
1619 $page = $this->createPage( __METHOD__
, 'Goat' );
1621 $user = $user === null ?
$user : $this->getTestSysop()->getUser();
1623 $result = $page->insertProtectNullRevision(
1632 $this->assertTrue( $result instanceof Revision
);
1633 $this->assertSame( $expectedComment, $result->getComment( Revision
::RAW
) );
1637 * @covers WikiPage::updateRevisionOn
1639 public function testUpdateRevisionOn_existingPage() {
1640 $user = $this->getTestSysop()->getUser();
1641 $page = $this->createPage( __METHOD__
, 'StartText' );
1643 $revision = new Revision(
1646 'page' => $page->getId(),
1647 'title' => $page->getTitle(),
1648 'comment' => __METHOD__
,
1649 'minor_edit' => true,
1650 'text' => __METHOD__
. '-text',
1651 'len' => strlen( __METHOD__
. '-text' ),
1652 'user' => $user->getId(),
1653 'user_text' => $user->getName(),
1654 'timestamp' => '20170707040404',
1655 'content_model' => CONTENT_MODEL_WIKITEXT
,
1656 'content_format' => CONTENT_FORMAT_WIKITEXT
,
1660 $result = $page->updateRevisionOn( $this->db
, $revision );
1661 $this->assertTrue( $result );
1662 $this->assertSame( 9989, $page->getLatest() );
1663 $this->assertEquals( $revision, $page->getRevision() );
1667 * @covers WikiPage::updateRevisionOn
1669 public function testUpdateRevisionOn_NonExistingPage() {
1670 $user = $this->getTestSysop()->getUser();
1671 $page = $this->createPage( __METHOD__
, 'StartText' );
1672 $page->doDeleteArticle( 'reason' );
1674 $revision = new Revision(
1677 'page' => $page->getId(),
1678 'title' => $page->getTitle(),
1679 'comment' => __METHOD__
,
1680 'minor_edit' => true,
1681 'text' => __METHOD__
. '-text',
1682 'len' => strlen( __METHOD__
. '-text' ),
1683 'user' => $user->getId(),
1684 'user_text' => $user->getName(),
1685 'timestamp' => '20170707040404',
1686 'content_model' => CONTENT_MODEL_WIKITEXT
,
1687 'content_format' => CONTENT_FORMAT_WIKITEXT
,
1691 $result = $page->updateRevisionOn( $this->db
, $revision );
1692 $this->assertFalse( $result );
1696 * @covers WikiPage::updateIfNewerOn
1698 public function testUpdateIfNewerOn_olderRevision() {
1699 $user = $this->getTestSysop()->getUser();
1700 $page = $this->createPage( __METHOD__
, 'StartText' );
1701 $initialRevision = $page->getRevision();
1703 $olderTimeStamp = wfTimestamp(
1705 wfTimestamp( TS_UNIX
, $initialRevision->getTimestamp() ) - 1
1708 $olderRevison = new Revision(
1711 'page' => $page->getId(),
1712 'title' => $page->getTitle(),
1713 'comment' => __METHOD__
,
1714 'minor_edit' => true,
1715 'text' => __METHOD__
. '-text',
1716 'len' => strlen( __METHOD__
. '-text' ),
1717 'user' => $user->getId(),
1718 'user_text' => $user->getName(),
1719 'timestamp' => $olderTimeStamp,
1720 'content_model' => CONTENT_MODEL_WIKITEXT
,
1721 'content_format' => CONTENT_FORMAT_WIKITEXT
,
1725 $result = $page->updateIfNewerOn( $this->db
, $olderRevison );
1726 $this->assertFalse( $result );
1730 * @covers WikiPage::updateIfNewerOn
1732 public function testUpdateIfNewerOn_newerRevision() {
1733 $user = $this->getTestSysop()->getUser();
1734 $page = $this->createPage( __METHOD__
, 'StartText' );
1735 $initialRevision = $page->getRevision();
1737 $newerTimeStamp = wfTimestamp(
1739 wfTimestamp( TS_UNIX
, $initialRevision->getTimestamp() ) +
1
1742 $newerRevision = new Revision(
1745 'page' => $page->getId(),
1746 'title' => $page->getTitle(),
1747 'comment' => __METHOD__
,
1748 'minor_edit' => true,
1749 'text' => __METHOD__
. '-text',
1750 'len' => strlen( __METHOD__
. '-text' ),
1751 'user' => $user->getId(),
1752 'user_text' => $user->getName(),
1753 'timestamp' => $newerTimeStamp,
1754 'content_model' => CONTENT_MODEL_WIKITEXT
,
1755 'content_format' => CONTENT_FORMAT_WIKITEXT
,
1758 $result = $page->updateIfNewerOn( $this->db
, $newerRevision );
1759 $this->assertTrue( $result );
1763 * @covers WikiPage::insertOn
1765 public function testInsertOn() {
1766 $title = Title
::newFromText( __METHOD__
);
1767 $page = new WikiPage( $title );
1769 $startTimeStamp = wfTimestampNow();
1770 $result = $page->insertOn( $this->db
);
1771 $endTimeStamp = wfTimestampNow();
1773 $this->assertInternalType( 'int', $result );
1774 $this->assertTrue( $result > 0 );
1776 $condition = [ 'page_id' => $result ];
1778 // Check the default fields have been filled
1779 $this->assertSelect(
1784 'page_restrictions',
1802 // Check the page_random field has been filled
1803 $pageRandom = $this->db
->selectField( 'page', 'page_random', $condition );
1804 $this->assertTrue( (float)$pageRandom < 1 && (float)$pageRandom > 0 );
1806 // Assert the touched timestamp in the DB is roughly when we inserted the page
1807 $pageTouched = $this->db
->selectField( 'page', 'page_touched', $condition );
1809 wfTimestamp( TS_UNIX
, $startTimeStamp )
1810 <= wfTimestamp( TS_UNIX
, $pageTouched )
1813 wfTimestamp( TS_UNIX
, $endTimeStamp )
1814 >= wfTimestamp( TS_UNIX
, $pageTouched )
1817 // Try inserting the same page again and checking the result is false (no change)
1818 $result = $page->insertOn( $this->db
);
1819 $this->assertFalse( $result );
1823 * @covers WikiPage::insertOn
1825 public function testInsertOn_idSpecified() {
1826 $title = Title
::newFromText( __METHOD__
);
1827 $page = new WikiPage( $title );
1830 $result = $page->insertOn( $this->db
, $id );
1832 $this->assertSame( $id, $result );
1834 $condition = [ 'page_id' => $result ];
1836 // Check there is actually a row in the db
1837 $this->assertSelect(
1845 public function provideTestDoUpdateRestrictions_setBasicRestrictions() {
1846 // Note: Once the current dates passes the date in these tests they will fail.
1847 yield
'move something' => [
1849 [ 'move' => 'something' ],
1851 [ 'edit' => [], 'move' => [ 'something' ] ],
1854 yield
'move something, edit blank' => [
1856 [ 'move' => 'something', 'edit' => '' ],
1858 [ 'edit' => [], 'move' => [ 'something' ] ],
1861 yield
'edit sysop, with expiry' => [
1863 [ 'edit' => 'sysop' ],
1864 [ 'edit' => '21330101020202' ],
1865 [ 'edit' => [ 'sysop' ], 'move' => [] ],
1866 [ 'edit' => '21330101020202' ],
1868 yield
'move and edit, move with expiry' => [
1870 [ 'move' => 'something', 'edit' => 'another' ],
1871 [ 'move' => '22220202010101' ],
1872 [ 'edit' => [ 'another' ], 'move' => [ 'something' ] ],
1873 [ 'move' => '22220202010101' ],
1875 yield
'move and edit, edit with infinity expiry' => [
1877 [ 'move' => 'something', 'edit' => 'another' ],
1878 [ 'edit' => 'infinity' ],
1879 [ 'edit' => [ 'another' ], 'move' => [ 'something' ] ],
1880 [ 'edit' => 'infinity' ],
1882 yield
'non existing, create something' => [
1884 [ 'create' => 'something' ],
1886 [ 'create' => [ 'something' ] ],
1889 yield
'non existing, create something with expiry' => [
1891 [ 'create' => 'something' ],
1892 [ 'create' => '23451212112233' ],
1893 [ 'create' => [ 'something' ] ],
1894 [ 'create' => '23451212112233' ],
1899 * @dataProvider provideTestDoUpdateRestrictions_setBasicRestrictions
1900 * @covers WikiPage::doUpdateRestrictions
1902 public function testDoUpdateRestrictions_setBasicRestrictions(
1906 array $expectedRestrictions,
1907 array $expectedRestrictionExpiries
1909 if ( $pageExists ) {
1910 $page = $this->createPage( __METHOD__
, 'ABC' );
1912 $page = new WikiPage( Title
::newFromText( __METHOD__
. '-nonexist' ) );
1914 $user = $this->getTestSysop()->getUser();
1917 $status = $page->doUpdateRestrictions( $limit, $expiry, $cascade, 'aReason', $user, [] );
1919 $logId = $status->getValue();
1920 $allRestrictions = $page->getTitle()->getAllRestrictions();
1922 $this->assertTrue( $status->isGood() );
1923 $this->assertInternalType( 'int', $logId );
1924 $this->assertSame( $expectedRestrictions, $allRestrictions );
1925 foreach ( $expectedRestrictionExpiries as $key => $value ) {
1926 $this->assertSame( $value, $page->getTitle()->getRestrictionExpiry( $key ) );
1929 // Make sure the log entry looks good
1930 // log_params is not checked here
1931 $actorQuery = ActorMigration
::newMigration()->getJoin( 'log_user' );
1932 $this->assertSelect(
1933 [ 'logging' ] +
$actorQuery['tables'],
1936 'log_user' => $actorQuery['fields']['log_user'],
1937 'log_user_text' => $actorQuery['fields']['log_user_text'],
1941 [ 'log_id' => $logId ],
1944 (string)$user->getId(),
1946 (string)$page->getTitle()->getNamespace(),
1947 $page->getTitle()->getDBkey(),
1950 $actorQuery['joins']
1955 * @covers WikiPage::doUpdateRestrictions
1957 public function testDoUpdateRestrictions_failsOnReadOnly() {
1958 $page = $this->createPage( __METHOD__
, 'ABC' );
1959 $user = $this->getTestSysop()->getUser();
1963 $readOnly = $this->getMockBuilder( ReadOnlyMode
::class )
1964 ->disableOriginalConstructor()
1965 ->setMethods( [ 'isReadOnly', 'getReason' ] )
1967 $readOnly->expects( $this->once() )
1968 ->method( 'isReadOnly' )
1969 ->will( $this->returnValue( true ) );
1970 $readOnly->expects( $this->once() )
1971 ->method( 'getReason' )
1972 ->will( $this->returnValue( 'Some Read Only Reason' ) );
1973 $this->setService( 'ReadOnlyMode', $readOnly );
1975 $status = $page->doUpdateRestrictions( [], [], $cascade, 'aReason', $user, [] );
1976 $this->assertFalse( $status->isOK() );
1977 $this->assertSame( 'readonlytext', $status->getMessage()->getKey() );
1981 * @covers WikiPage::doUpdateRestrictions
1983 public function testDoUpdateRestrictions_returnsGoodIfNothingChanged() {
1984 $page = $this->createPage( __METHOD__
, 'ABC' );
1985 $user = $this->getTestSysop()->getUser();
1987 $limit = [ 'edit' => 'sysop' ];
1989 $status = $page->doUpdateRestrictions(
1998 // The first entry should have a logId as it did something
1999 $this->assertTrue( $status->isGood() );
2000 $this->assertInternalType( 'int', $status->getValue() );
2002 $status = $page->doUpdateRestrictions(
2011 // The second entry should not have a logId as nothing changed
2012 $this->assertTrue( $status->isGood() );
2013 $this->assertNull( $status->getValue() );
2017 * @covers WikiPage::doUpdateRestrictions
2019 public function testDoUpdateRestrictions_logEntryTypeAndAction() {
2020 $page = $this->createPage( __METHOD__
, 'ABC' );
2021 $user = $this->getTestSysop()->getUser();
2025 $status = $page->doUpdateRestrictions(
2026 [ 'edit' => 'sysop' ],
2033 $this->assertTrue( $status->isGood() );
2034 $this->assertInternalType( 'int', $status->getValue() );
2035 $this->assertSelect(
2037 [ 'log_type', 'log_action' ],
2038 [ 'log_id' => $status->getValue() ],
2039 [ [ 'protect', 'protect' ] ]
2042 // Modify the protection
2043 $status = $page->doUpdateRestrictions(
2044 [ 'edit' => 'somethingElse' ],
2051 $this->assertTrue( $status->isGood() );
2052 $this->assertInternalType( 'int', $status->getValue() );
2053 $this->assertSelect(
2055 [ 'log_type', 'log_action' ],
2056 [ 'log_id' => $status->getValue() ],
2057 [ [ 'protect', 'modify' ] ]
2060 // Remove the protection
2061 $status = $page->doUpdateRestrictions(
2069 $this->assertTrue( $status->isGood() );
2070 $this->assertInternalType( 'int', $status->getValue() );
2071 $this->assertSelect(
2073 [ 'log_type', 'log_action' ],
2074 [ 'log_id' => $status->getValue() ],
2075 [ [ 'protect', 'unprotect' ] ]