<?php
+use MediaWiki\Edit\PreparedEdit;
+use MediaWiki\MediaWikiServices;
use MediaWiki\Storage\RevisionSlotsUpdate;
+use PHPUnit\Framework\MockObject\MockObject;
use Wikimedia\TestingAccessWrapper;
/**
/**
* @param string|Title|WikiPage $page
- * @param string $text
- * @param int $model
+ * @param string|Content|Content[] $content
+ * @param int|null $model
*
* @return WikiPage
*/
- protected function createPage( $page, $text, $model = null, $user = null ) {
+ protected function createPage( $page, $content, $model = null, $user = null ) {
if ( is_string( $page ) || $page instanceof Title ) {
$page = $this->newPage( $page, $model );
}
- $content = ContentHandler::makeContent( $text, $page->getTitle(), $model );
- $page->doEditContent( $content, "testing", EDIT_NEW, false, $user );
+ if ( !$user ) {
+ $user = $this->getTestUser()->getUser();
+ }
+
+ if ( is_string( $content ) ) {
+ $content = ContentHandler::makeContent( $content, $page->getTitle(), $model );
+ }
+
+ if ( !is_array( $content ) ) {
+ $content = [ 'main' => $content ];
+ }
+
+ $updater = $page->newPageUpdater( $user );
+
+ foreach ( $content as $role => $cnt ) {
+ $updater->setContent( $role, $cnt );
+ }
+
+ $updater->saveRevision( CommentStoreComment::newUnsavedComment( "testing" ) );
return $page;
}
// Re-using the prepared info if possible
$sameEdit = $page->prepareContentForEdit( $content, null, $user, null, false );
- $this->assertEquals( $edit, $sameEdit, 'equivalent PreparedEdit' );
+ $this->assertPreparedEditEquals( $edit, $sameEdit, 'equivalent PreparedEdit' );
$this->assertSame( $edit->pstContent, $sameEdit->pstContent, 're-use output' );
$this->assertSame( $edit->output, $sameEdit->output, 're-use output' );
// Not re-using the same PreparedEdit if not possible
$rev = $page->getRevision();
$edit2 = $page->prepareContentForEdit( $content2, null, $user, null, false );
- $this->assertNotEquals( $edit, $edit2 );
+ $this->assertPreparedEditNotEquals( $edit, $edit2 );
$this->assertContains( 'At vero eos', $edit2->pstContent->serialize(), "content" );
// Check pre-safe transform
$this->assertNotContains( '~~~~', $edit2->pstContent->serialize() );
$edit3 = $page->prepareContentForEdit( $content2, null, $sysop, null, false );
- $this->assertNotEquals( $edit2, $edit3 );
+ $this->assertPreparedEditNotEquals( $edit2, $edit3 );
// TODO: test with passing revision, then same without revision.
}
CONTENT_MODEL_WIKITEXT
);
+ $preparedEditBefore = $page->prepareContentForEdit( $content, null, $user1 );
+
$status = $page->doEditContent( $content, "[[testing]] 1", EDIT_NEW, false, $user1 );
$this->assertTrue( $status->isOK(), 'OK' );
$this->assertTrue( $status->value['revision']->getContent()->equals( $content ), 'equals' );
$rev = $page->getRevision();
+ $preparedEditAfter = $page->prepareContentForEdit( $content, $rev, $user1 );
+
$this->assertNotNull( $rev->getRecentChange() );
$this->assertSame( $rev->getId(), (int)$rev->getRecentChange()->getAttribute( 'rc_this_oldid' ) );
+ // make sure that cached ParserOutput gets re-used throughout
+ $this->assertSame( $preparedEditBefore->output, $preparedEditAfter->output );
+
$id = $page->getId();
// Test page creation logging
$this->assertEquals( 2, $n, 'pagelinks should contain two links from the page' );
}
+ /**
+ * @covers WikiPage::doEditContent
+ */
+ public function testDoEditContent_twice() {
+ $title = Title::newFromText( __METHOD__ );
+ $page = WikiPage::factory( $title );
+ $content = ContentHandler::makeContent( '$1 van $2', $title );
+
+ // Make sure we can do the exact same save twice.
+ // This tests checks that internal caches are reset as appropriate.
+ $status1 = $page->doEditContent( $content, __METHOD__ );
+ $status2 = $page->doEditContent( $content, __METHOD__ );
+
+ $this->assertTrue( $status1->isOK(), 'OK' );
+ $this->assertTrue( $status2->isOK(), 'OK' );
+
+ $this->assertTrue( isset( $status1->value['revision'] ), 'OK' );
+ $this->assertFalse( isset( $status2->value['revision'] ), 'OK' );
+ }
+
/**
* Undeletion is covered in PageArchiveTest::testUndeleteRevisions()
* TODO: Revision deletion
* @covers WikiPage::doDeleteUpdates
*/
public function testDoDeleteUpdates() {
+ $user = $this->getTestUser()->getUser();
$page = $this->createPage(
__METHOD__,
"[[original text]] foo",
CONTENT_MODEL_WIKITEXT
);
$id = $page->getId();
+ $page->loadPageData(); // make sure the current revision is cached.
// Similar to MovePage logic
wfGetDB( DB_MASTER )->delete( 'page', [ 'page_id' => $id ], __METHOD__ );
- $page->doDeleteUpdates( $id );
+ $page->doDeleteUpdates( $page->getId(), $page->getContent(), $page->getRevision(), $user );
// Run the job queue
JobQueueGroup::destroySingletons();
$this->assertEquals( 0, $n, 'pagelinks should contain no more links from the page' );
}
+ /**
+ * @param string $name
+ *
+ * @return ContentHandler
+ */
+ protected function defineMockContentModelForUpdateTesting( $name ) {
+ /** @var ContentHandler|MockObject $handler */
+ $handler = $this->getMockBuilder( TextContentHandler::class )
+ ->setConstructorArgs( [ $name ] )
+ ->setMethods(
+ [ 'getSecondaryDataUpdates', 'getDeletionUpdates', 'unserializeContent' ]
+ )
+ ->getMock();
+
+ $dataUpdate = new MWCallableUpdate( 'time' );
+ $dataUpdate->_name = "$name data update";
+
+ $deletionUpdate = new MWCallableUpdate( 'time' );
+ $deletionUpdate->_name = "$name deletion update";
+
+ $handler->method( 'getSecondaryDataUpdates' )->willReturn( [ $dataUpdate ] );
+ $handler->method( 'getDeletionUpdates' )->willReturn( [ $deletionUpdate ] );
+ $handler->method( 'unserializeContent' )->willReturnCallback(
+ function ( $text ) use ( $handler ) {
+ return $this->createMockContent( $handler, $text );
+ }
+ );
+
+ $this->mergeMwGlobalArrayValue(
+ 'wgContentHandlers', [
+ $name => function () use ( $handler ){
+ return $handler;
+ }
+ ]
+ );
+
+ return $handler;
+ }
+
+ /**
+ * @param ContentHandler $handler
+ * @param string $text
+ *
+ * @return Content
+ */
+ protected function createMockContent( ContentHandler $handler, $text ) {
+ /** @var Content|MockObject $content */
+ $content = $this->getMockBuilder( TextContent::class )
+ ->setConstructorArgs( [ $text ] )
+ ->setMethods( [ 'getModel', 'getContentHandler' ] )
+ ->getMock();
+
+ $content->method( 'getModel' )->willReturn( $handler->getModelID() );
+ $content->method( 'getContentHandler' )->willReturn( $handler );
+
+ return $content;
+ }
+
+ public function testGetDeletionUpdates() {
+ $m1 = $this->defineMockContentModelForUpdateTesting( 'M1' );
+
+ $mainContent1 = $this->createMockContent( $m1, 'main 1' );
+
+ $page = new WikiPage( Title::newFromText( __METHOD__ ) );
+ $page = $this->createPage(
+ $page,
+ [ 'main' => $mainContent1 ]
+ );
+
+ $dataUpdates = $page->getDeletionUpdates( $page->getRevisionRecord() );
+ $this->assertNotEmpty( $dataUpdates );
+
+ $updateNames = array_map( function ( $du ) {
+ return isset( $du->_name ) ? $du->_name : get_class( $du );
+ }, $dataUpdates );
+
+ $this->assertContains( LinksDeletionUpdate::class, $updateNames );
+ $this->assertContains( 'M1 deletion update', $updateNames );
+ }
+
/**
* @covers WikiPage::getRevision
*/
* @covers WikiPage::commitRollback
*/
public function testDoRollback() {
+ // FIXME: fails under postgres
+ $this->markTestSkippedIfDbType( 'postgres' );
+
$admin = $this->getTestSysop()->getUser();
$user1 = $this->getTestUser()->getUser();
// Use the confirmed group for user2 to make sure the user is different
$user2 = $this->getTestUser( [ 'confirmed' ] )->getUser();
+ // make sure we can test autopatrolling
+ $this->setMwGlobals( 'wgUseRCPatrol', true );
+
+ // TODO: MCR: test rollback of multiple slots!
$page = $this->newPage( __METHOD__ );
// Make some edits
$this->assertEquals( $rev2->getSha1(), $page->getRevision()->getSha1(),
"rollback did not revert to the correct revision" );
$this->assertEquals( "one\n\ntwo", $page->getContent()->getNativeData() );
- }
-
- /**
- * @covers WikiPage::doRollback
- * @covers WikiPage::commitRollback
- */
- public function testDoRollback_simple() {
- $admin = $this->getTestSysop()->getUser();
-
- $text = "one";
- $page = $this->newPage( __METHOD__ );
- $page->doEditContent(
- ContentHandler::makeContent( $text, $page->getTitle(), CONTENT_MODEL_WIKITEXT ),
- "section one",
- EDIT_NEW,
- false,
- $admin
- );
- $rev1 = $page->getRevision();
- $user1 = $this->getTestUser()->getUser();
- $text .= "\n\ntwo";
- $page = new WikiPage( $page->getTitle() );
- $page->doEditContent(
- ContentHandler::makeContent( $text, $page->getTitle(), CONTENT_MODEL_WIKITEXT ),
- "adding section two",
- 0,
- false,
- $user1
+ $rc = MediaWikiServices::getInstance()->getRevisionStore()->getRecentChange(
+ $page->getRevision()->getRevisionRecord()
);
- # now, try the rollback
- $token = $admin->getEditToken( 'rollback' );
- $errors = $page->doRollback(
- $user1->getName(),
- "testing revert",
- $token,
- false,
- $details,
- $admin
+ $this->assertNotNull( $rc, 'RecentChanges entry' );
+ $this->assertEquals(
+ RecentChange::PRC_AUTOPATROLLED,
+ $rc->getAttribute( 'rc_patrolled' ),
+ 'rc_patrolled'
);
- if ( $errors ) {
- $this->fail( "Rollback failed:\n" . print_r( $errors, true )
- . ";\n" . print_r( $details, true ) );
- }
-
- $page = new WikiPage( $page->getTitle() );
- $this->assertEquals( $rev1->getSha1(), $page->getRevision()->getSha1(),
- "rollback did not revert to the correct revision" );
- $this->assertEquals( "one", $page->getContent()->getNativeData() );
+ // TODO: MCR: assert origin once we write slot data
+ // $mainSlot = $page->getRevision()->getRevisionRecord()->getSlot( 'main' );
+ // $this->assertTrue( $mainSlot->isInherited(), 'isInherited' );
+ // $this->assertSame( $rev2->getId(), $mainSlot->getOrigin(), 'getOrigin' );
}
/**
$expectedSuccess,
$expectedRowCount
) {
+ // FIXME: fails under sqlite and postgres
+ $this->markTestSkippedIfDbType( 'sqlite' );
+ $this->markTestSkippedIfDbType( 'postgres' );
static $pageCounter = 0;
$pageCounter++;
->method( 'getParserOutput' )
->willReturn( new ParserOutput( 'HTML' ) );
- $updater = $page->newPageUpdater( $user );
+ $preparedEditBefore = $page->prepareContentForEdit( $content, null, $user );
+
+ // provide context, so the cache can be kept in place
+ $slotsUpdate = new revisionSlotsUpdate();
+ $slotsUpdate->modifyContent( 'main', $content );
+
+ $updater = $page->newPageUpdater( $user, $slotsUpdate );
$updater->setContent( 'main', $content );
$revision = $updater->saveRevision(
CommentStoreComment::newUnsavedComment( 'test' ),
EDIT_NEW
);
+ $preparedEditAfter = $page->prepareContentForEdit( $content, $revision, $user );
+
$this->assertSame( $revision->getId(), $page->getLatest() );
+
+ // Parsed output must remain cached throughout.
+ $this->assertSame( $preparedEditBefore->output, $preparedEditAfter->output );
}
/**
$updater1->prepareUpdate( $revision );
- // Re-use updater with same revision or content
+ // Re-use updater with same revision or content, even if base changed
$this->assertSame( $updater1, $page->getDerivedDataUpdater( $user, $revision ) );
$slotsUpdate = RevisionSlotsUpdate::newFromContent(
);
$this->assertSame( $updater1, $page->getDerivedDataUpdater( $user, null, $slotsUpdate ) );
+ // Don't re-use for edit if base revision ID changed
+ $this->assertNotSame(
+ $updater1,
+ $page->getDerivedDataUpdater( $user, null, $slotsUpdate, true )
+ );
+
// Don't re-use with different user
$updater2a = $page->getDerivedDataUpdater( $admin, null, $slotsUpdate );
$updater2a->prepareContent( $admin, $slotsUpdate, false );
$this->assertNotSame( $updater5, $updater6 );
}
+ protected function assertPreparedEditEquals(
+ PreparedEdit $edit, PreparedEdit $edit2, $message = ''
+ ) {
+ // suppress differences caused by a clock tick between generating the two PreparedEdits
+ if ( abs( $edit->timestamp - $edit2->timestamp ) < 3 ) {
+ $edit2 = clone $edit2;
+ $edit2->timestamp = $edit->timestamp;
+ }
+ $this->assertEquals( $edit, $edit2, $message );
+ }
+
+ protected function assertPreparedEditNotEquals(
+ PreparedEdit $edit, PreparedEdit $edit2, $message = ''
+ ) {
+ if ( abs( $edit->timestamp - $edit2->timestamp ) < 3 ) {
+ $edit2 = clone $edit2;
+ $edit2->timestamp = $edit->timestamp;
+ }
+ $this->assertNotEquals( $edit, $edit2, $message );
+ }
+
}
dépôts / lhc / web / wiklou.git / blobdiff